mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-01-18 15:15:56 +08:00
[svn-r26302] Description:
Revise dataspace encode/decode routines to make them work better with
future virtual dataset feature.
Tested on:
Mac OSX/64 10.10.2 (amazon) w/serial
(h5committest forthcoming)
This commit is contained in:
Quincey Koziol
parent
0ce8fddc73
commit
3550004b20
@ -291,7 +291,7 @@ H5R_create(void *_ref, H5G_loc_t *loc, const char *name, H5R_type_t ref_type, H5
|
||||
H5F_addr_encode(loc->oloc->file, &p, obj_loc.oloc->addr);
|
||||
|
||||
/* Serialize the selection into heap buffer */
|
||||
if(H5S_SELECT_SERIALIZE(space, p) < 0)
|
||||
if(H5S_SELECT_SERIALIZE(space, &p) < 0)
|
||||
HGOTO_ERROR(H5E_REFERENCE, H5E_CANTCOPY, FAIL, "Unable to serialize selection")
|
||||
|
||||
/* Save the serialized buffer for later */
|
||||
@ -659,7 +659,7 @@ H5R_get_region(H5F_t *file, hid_t dxpl_id, const void *_ref)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_NOTFOUND, NULL, "not found")
|
||||
|
||||
/* Unserialize the selection */
|
||||
if(H5S_select_deserialize(ret_value, p) < 0)
|
||||
if(H5S_SELECT_DESERIALIZE(&ret_value, &p) < 0)
|
||||
HGOTO_ERROR(H5E_REFERENCE, H5E_CANTDECODE, NULL, "can't deserialize selection")
|
||||
|
||||
done:
|
||||
|
||||
@ -1540,7 +1540,7 @@ H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc)
|
||||
buf += extent_size;
|
||||
|
||||
/* Encode the selection part of dataspace. */
|
||||
if(H5S_SELECT_SERIALIZE(obj, buf) < 0)
|
||||
if(H5S_SELECT_SERIALIZE(obj, &buf) < 0)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode select space")
|
||||
} /* end else */
|
||||
|
||||
@ -1659,7 +1659,7 @@ H5S_decode(const unsigned char *buf)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection")
|
||||
|
||||
/* Decode the select part of dataspace. I believe this part always exists. */
|
||||
if(H5S_SELECT_DESERIALIZE(ds, buf) < 0)
|
||||
if(H5S_SELECT_DESERIALIZE(&ds, &buf) < 0)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode space selection")
|
||||
|
||||
/* Set return value */
|
||||
|
||||
41
src/H5Sall.c
41
src/H5Sall.c
@ -39,8 +39,8 @@ static herr_t H5S_all_get_seq_list(const H5S_t *space, unsigned flags,
|
||||
static herr_t H5S_all_release(H5S_t *space);
|
||||
static htri_t H5S_all_is_valid(const H5S_t *space);
|
||||
static hssize_t H5S_all_serial_size(const H5S_t *space);
|
||||
static herr_t H5S_all_serialize(const H5S_t *space, uint8_t *buf);
|
||||
static herr_t H5S_all_deserialize(H5S_t *space, const uint8_t *buf);
|
||||
static herr_t H5S_all_serialize(const H5S_t *space, uint8_t **p);
|
||||
static herr_t H5S_all_deserialize(H5S_t *space, const uint8_t **p);
|
||||
static herr_t H5S_all_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
|
||||
static herr_t H5S_all_offset(const H5S_t *space, hsize_t *off);
|
||||
static htri_t H5S_all_is_contiguous(const H5S_t *space);
|
||||
@ -496,9 +496,11 @@ H5S_all_serial_size (const H5S_t UNUSED *space)
|
||||
PURPOSE
|
||||
Serialize the current selection into a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_all_serialize(space, buf)
|
||||
H5S_t *space; IN: Dataspace pointer of selection to serialize
|
||||
uint8 *buf; OUT: Buffer to put serialized selection into
|
||||
herr_t H5S_all_serialize(space, p)
|
||||
const H5S_t *space; IN: Dataspace with selection to serialize
|
||||
uint8_t **p; OUT: Pointer to buffer to put serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -510,17 +512,19 @@ H5S_all_serial_size (const H5S_t UNUSED *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_all_serialize (const H5S_t *space, uint8_t *buf)
|
||||
H5S_all_serialize (const H5S_t *space, uint8_t **p)
|
||||
{
|
||||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||||
|
||||
HDassert(space);
|
||||
HDassert(p);
|
||||
HDassert(*p);
|
||||
|
||||
/* Store the preamble information */
|
||||
UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(buf, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the un-used padding */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the additional information length */
|
||||
UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(*p, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the un-used padding */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the additional information length */
|
||||
|
||||
FUNC_LEAVE_NOAPI(SUCCEED)
|
||||
} /* H5S_all_serialize() */
|
||||
@ -532,9 +536,12 @@ H5S_all_serialize (const H5S_t *space, uint8_t *buf)
|
||||
PURPOSE
|
||||
Deserialize the current selection from a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_all_deserialize(space, buf)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place selection into
|
||||
uint8 *buf; IN: Buffer to retrieve serialized selection from
|
||||
herr_t H5S_all_deserialize(space, p)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place
|
||||
selection into
|
||||
uint8 **p; OUT: Pointer to buffer holding serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -546,16 +553,18 @@ H5S_all_serialize (const H5S_t *space, uint8_t *buf)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_all_deserialize(H5S_t *space, const uint8_t UNUSED *buf)
|
||||
H5S_all_deserialize(H5S_t *space, const uint8_t UNUSED **p)
|
||||
{
|
||||
herr_t ret_value; /* return value */
|
||||
herr_t ret_value = SUCCEED; /* return value */
|
||||
|
||||
FUNC_ENTER_NOAPI(FAIL)
|
||||
|
||||
HDassert(space);
|
||||
HDassert(p);
|
||||
HDassert(*p);
|
||||
|
||||
/* Change to "all" selection */
|
||||
if((ret_value = H5S_select_all(space, TRUE)) < 0)
|
||||
if(H5S_select_all(space, TRUE) < 0)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection")
|
||||
|
||||
done:
|
||||
|
||||
@ -54,8 +54,8 @@ static herr_t H5S_hyper_get_seq_list(const H5S_t *space, unsigned flags,
|
||||
static herr_t H5S_hyper_release(H5S_t *space);
|
||||
static htri_t H5S_hyper_is_valid(const H5S_t *space);
|
||||
static hssize_t H5S_hyper_serial_size(const H5S_t *space);
|
||||
static herr_t H5S_hyper_serialize(const H5S_t *space, uint8_t *buf);
|
||||
static herr_t H5S_hyper_deserialize(H5S_t *space, const uint8_t *buf);
|
||||
static herr_t H5S_hyper_serialize(const H5S_t *space, uint8_t **p);
|
||||
static herr_t H5S_hyper_deserialize(H5S_t *space, const uint8_t **p);
|
||||
static herr_t H5S_hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
|
||||
static herr_t H5S_hyper_offset(const H5S_t *space, hsize_t *offset);
|
||||
static htri_t H5S_hyper_is_contiguous(const H5S_t *space);
|
||||
@ -1994,7 +1994,7 @@ H5S_hyper_serial_size(const H5S_t *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank, uint8_t **buf)
|
||||
H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank, uint8_t **p)
|
||||
{
|
||||
H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */
|
||||
hsize_t u; /* Index variable */
|
||||
@ -2007,7 +2007,7 @@ H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start,
|
||||
HDassert(start);
|
||||
HDassert(end);
|
||||
HDassert(rank < H5O_LAYOUT_NDIMS);
|
||||
HDassert(buf && *buf);
|
||||
HDassert(p && *p);
|
||||
|
||||
/* Walk through the list of spans, recursing or outputing them */
|
||||
curr=spans->head;
|
||||
@ -2019,7 +2019,7 @@ H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start,
|
||||
end[rank]=curr->high;
|
||||
|
||||
/* Recurse down to the next dimension */
|
||||
if(H5S_hyper_serialize_helper(curr->down,start,end,rank+1,buf)<0)
|
||||
if(H5S_hyper_serialize_helper(curr->down,start,end,rank+1,p)<0)
|
||||
HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
|
||||
} /* end if */
|
||||
else {
|
||||
@ -2027,17 +2027,17 @@ H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start,
|
||||
|
||||
/* Encode previous starting points */
|
||||
for(u=0; u<rank; u++)
|
||||
UINT32ENCODE(*buf, (uint32_t)start[u]);
|
||||
UINT32ENCODE(*p, (uint32_t)start[u]);
|
||||
|
||||
/* Encode starting point for this span */
|
||||
UINT32ENCODE(*buf, (uint32_t)curr->low);
|
||||
UINT32ENCODE(*p, (uint32_t)curr->low);
|
||||
|
||||
/* Encode previous ending points */
|
||||
for(u=0; u<rank; u++)
|
||||
UINT32ENCODE(*buf, (uint32_t)end[u]);
|
||||
UINT32ENCODE(*p, (uint32_t)end[u]);
|
||||
|
||||
/* Encode starting point for this span */
|
||||
UINT32ENCODE(*buf, (uint32_t)curr->high);
|
||||
UINT32ENCODE(*p, (uint32_t)curr->high);
|
||||
} /* end else */
|
||||
|
||||
/* Advance to next node */
|
||||
@ -2055,9 +2055,11 @@ done:
|
||||
PURPOSE
|
||||
Serialize the current selection into a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_hyper_serialize(space, buf)
|
||||
H5S_t *space; IN: Dataspace pointer of selection to serialize
|
||||
uint8 *buf; OUT: Buffer to put serialized selection into
|
||||
herr_t H5S_hyper_serialize(space, p)
|
||||
const H5S_t *space; IN: Dataspace with selection to serialize
|
||||
uint8_t **p; OUT: Pointer to buffer to put serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -2069,7 +2071,7 @@ done:
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
H5S_hyper_serialize (const H5S_t *space, uint8_t **p)
|
||||
{
|
||||
const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */
|
||||
hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab counts */
|
||||
@ -2089,14 +2091,14 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
HDassert(space);
|
||||
|
||||
/* Store the preamble information */
|
||||
UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(buf, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the un-used padding */
|
||||
lenp = buf; /* keep the pointer to the length location for later */
|
||||
buf += 4; /* skip over space for length */
|
||||
UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(*p, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the un-used padding */
|
||||
lenp = *p; /* keep the pointer to the length location for later */
|
||||
*p += 4; /* skip over space for length */
|
||||
|
||||
/* Encode number of dimensions */
|
||||
UINT32ENCODE(buf, (uint32_t)space->extent.rank);
|
||||
UINT32ENCODE(*p, (uint32_t)space->extent.rank);
|
||||
len += 4;
|
||||
|
||||
/* Check for a "regular" hyperslab selection */
|
||||
@ -2114,7 +2116,7 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
|
||||
/* Encode number of hyperslabs */
|
||||
H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
|
||||
UINT32ENCODE(buf, (uint32_t)block_count);
|
||||
UINT32ENCODE(*p, (uint32_t)block_count);
|
||||
len+=4;
|
||||
|
||||
/* Now serialize the information for the regular hyperslab */
|
||||
@ -2137,11 +2139,11 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
|
||||
/* Encode hyperslab starting location */
|
||||
for(u = 0; u < ndims; u++)
|
||||
UINT32ENCODE(buf, (uint32_t)offset[u]);
|
||||
UINT32ENCODE(*p, (uint32_t)offset[u]);
|
||||
|
||||
/* Encode hyperslab ending location */
|
||||
for(u = 0; u < ndims; u++)
|
||||
UINT32ENCODE(buf, (uint32_t)(offset[u] + (diminfo[u].block - 1)));
|
||||
UINT32ENCODE(*p, (uint32_t)(offset[u] + (diminfo[u].block - 1)));
|
||||
|
||||
/* Move the offset to the next sequence to start */
|
||||
offset[fast_dim]+=diminfo[fast_dim].stride;
|
||||
@ -2192,15 +2194,15 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
/* Encode number of hyperslabs */
|
||||
block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
|
||||
H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
|
||||
UINT32ENCODE(buf, (uint32_t)block_count);
|
||||
UINT32ENCODE(*p, (uint32_t)block_count);
|
||||
len+=4;
|
||||
|
||||
/* Add 8 bytes times the rank for each hyperslab selected */
|
||||
H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, size_t);
|
||||
len += (size_t)(8 * space->extent.rank * block_count);
|
||||
len += (uint32_t)(8 * space->extent.rank * block_count);
|
||||
|
||||
/* Encode each hyperslab in selection */
|
||||
H5S_hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, &buf);
|
||||
H5S_hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, p);
|
||||
} /* end else */
|
||||
|
||||
/* Encode length */
|
||||
@ -2216,9 +2218,12 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
PURPOSE
|
||||
Deserialize the current selection from a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_hyper_deserialize(space, buf)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place selection into
|
||||
uint8 *buf; IN: Buffer to retrieve serialized selection from
|
||||
herr_t H5S_hyper_deserialize(space, p)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place
|
||||
selection into
|
||||
uint8 **p; OUT: Pointer to buffer holding serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -2230,9 +2235,9 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_hyper_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
H5S_hyper_deserialize (H5S_t *space, const uint8_t **p)
|
||||
{
|
||||
uint32_t rank; /* rank of points */
|
||||
unsigned rank; /* rank of points */
|
||||
size_t num_elem=0; /* number of elements in selection */
|
||||
hsize_t start[H5O_LAYOUT_NDIMS]; /* hyperslab start information */
|
||||
hsize_t end[H5O_LAYOUT_NDIMS]; /* hyperslab end information */
|
||||
@ -2251,14 +2256,13 @@ H5S_hyper_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
|
||||
/* Check args */
|
||||
HDassert(space);
|
||||
HDassert(buf);
|
||||
HDassert(p);
|
||||
HDassert(*p);
|
||||
|
||||
/* Deserialize slabs to select */
|
||||
buf+=16; /* Skip over selection header */
|
||||
UINT32DECODE(buf,rank); /* decode the rank of the point selection */
|
||||
if(rank!=space->extent.rank)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of pointer does not match dataspace")
|
||||
UINT32DECODE(buf,num_elem); /* decode the number of points */
|
||||
/* (The header and rank have already beed decoded) */
|
||||
rank = space->extent.rank; /* Retrieve rank from space */
|
||||
UINT32DECODE(*p,num_elem); /* decode the number of points */
|
||||
|
||||
/* Set the count & stride for all blocks */
|
||||
for(tcount=count,tstride=stride,j=0; j<rank; j++,tstride++,tcount++) {
|
||||
@ -2270,14 +2274,14 @@ H5S_hyper_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
for(i=0; i<num_elem; i++) {
|
||||
/* Decode the starting points */
|
||||
for(tstart=start,j=0; j<rank; j++,tstart++)
|
||||
UINT32DECODE(buf, *tstart);
|
||||
UINT32DECODE(*p, *tstart);
|
||||
|
||||
/* Decode the ending points */
|
||||
for(tend=end,j=0; j<rank; j++,tend++)
|
||||
UINT32DECODE(buf, *tend);
|
||||
UINT32DECODE(*p, *tend);
|
||||
|
||||
/* Change the ending points into blocks */
|
||||
for(tblock=block,tstart=start,tend=end,j=0; j<(unsigned)rank; j++,tstart++,tend++,tblock++)
|
||||
for(tblock=block,tstart=start,tend=end,j=0; j<rank; j++,tstart++,tend++,tblock++)
|
||||
*tblock=(*tend-*tstart)+1;
|
||||
|
||||
/* Select or add the hyperslab to the current selection */
|
||||
|
||||
@ -40,8 +40,8 @@ static herr_t H5S_none_get_seq_list(const H5S_t *space, unsigned flags,
|
||||
static herr_t H5S_none_release(H5S_t *space);
|
||||
static htri_t H5S_none_is_valid(const H5S_t *space);
|
||||
static hssize_t H5S_none_serial_size(const H5S_t *space);
|
||||
static herr_t H5S_none_serialize(const H5S_t *space, uint8_t *buf);
|
||||
static herr_t H5S_none_deserialize(H5S_t *space, const uint8_t *buf);
|
||||
static herr_t H5S_none_serialize(const H5S_t *space, uint8_t **p);
|
||||
static herr_t H5S_none_deserialize(H5S_t *space, const uint8_t **p);
|
||||
static herr_t H5S_none_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
|
||||
static herr_t H5S_none_offset(const H5S_t *space, hsize_t *off);
|
||||
static htri_t H5S_none_is_contiguous(const H5S_t *space);
|
||||
@ -464,9 +464,11 @@ H5S_none_serial_size(const H5S_t UNUSED *space)
|
||||
PURPOSE
|
||||
Serialize the current selection into a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_none_serialize(space, buf)
|
||||
H5S_t *space; IN: Dataspace pointer of selection to serialize
|
||||
uint8 *buf; OUT: Buffer to put serialized selection into
|
||||
herr_t H5S_none_serialize(space, p)
|
||||
const H5S_t *space; IN: Dataspace with selection to serialize
|
||||
uint8_t **p; OUT: Pointer to buffer to put serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -478,17 +480,17 @@ H5S_none_serial_size(const H5S_t UNUSED *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_none_serialize(const H5S_t *space, uint8_t *buf)
|
||||
H5S_none_serialize(const H5S_t *space, uint8_t **p)
|
||||
{
|
||||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||||
|
||||
HDassert(space);
|
||||
|
||||
/* Store the preamble information */
|
||||
UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(buf, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the un-used padding */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the additional information length */
|
||||
UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(*p, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the un-used padding */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the additional information length */
|
||||
|
||||
FUNC_LEAVE_NOAPI(SUCCEED)
|
||||
} /* H5S_none_serialize() */
|
||||
@ -500,9 +502,12 @@ H5S_none_serialize(const H5S_t *space, uint8_t *buf)
|
||||
PURPOSE
|
||||
Deserialize the current selection from a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_none_deserialize(space, buf)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place selection into
|
||||
uint8 *buf; IN: Buffer to retrieve serialized selection from
|
||||
herr_t H5S_none_deserialize(space, p)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place
|
||||
selection into
|
||||
uint8 **p; OUT: Pointer to buffer holding serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -514,13 +519,15 @@ H5S_none_serialize(const H5S_t *space, uint8_t *buf)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_none_deserialize(H5S_t *space, const uint8_t UNUSED *buf)
|
||||
H5S_none_deserialize(H5S_t *space, const uint8_t UNUSED **p)
|
||||
{
|
||||
herr_t ret_value = SUCCEED; /* return value */
|
||||
|
||||
FUNC_ENTER_NOAPI_NOINIT
|
||||
|
||||
HDassert(space);
|
||||
HDassert(p);
|
||||
HDassert(*p);
|
||||
|
||||
/* Change to "none" selection */
|
||||
if(H5S_select_none(space) < 0)
|
||||
|
||||
@ -130,9 +130,9 @@ typedef htri_t (*H5S_sel_is_valid_func_t)(const H5S_t *space);
|
||||
/* Method to determine number of bytes required to store current selection */
|
||||
typedef hssize_t (*H5S_sel_serial_size_func_t)(const H5S_t *space);
|
||||
/* Method to store current selection in "serialized" form (a byte sequence suitable for storing on disk) */
|
||||
typedef herr_t (*H5S_sel_serialize_func_t)(const H5S_t *space, uint8_t *buf);
|
||||
typedef herr_t (*H5S_sel_serialize_func_t)(const H5S_t *space, uint8_t **p);
|
||||
/* Method to store create selection from "serialized" form (a byte sequence suitable for storing on disk) */
|
||||
typedef herr_t (*H5S_sel_deserialize_func_t)(H5S_t *space, const uint8_t *buf);
|
||||
typedef herr_t (*H5S_sel_deserialize_func_t)(H5S_t *space, const uint8_t **p);
|
||||
/* Method to determine smallest n-D bounding box containing the current selection */
|
||||
typedef herr_t (*H5S_sel_bounds_func_t)(const H5S_t *space, hsize_t *start, hsize_t *end);
|
||||
/* Method to determine linear offset of initial element in selection within dataspace */
|
||||
|
||||
@ -41,8 +41,8 @@ static herr_t H5S_point_get_seq_list(const H5S_t *space, unsigned flags,
|
||||
static herr_t H5S_point_release(H5S_t *space);
|
||||
static htri_t H5S_point_is_valid(const H5S_t *space);
|
||||
static hssize_t H5S_point_serial_size(const H5S_t *space);
|
||||
static herr_t H5S_point_serialize(const H5S_t *space, uint8_t *buf);
|
||||
static herr_t H5S_point_deserialize(H5S_t *space, const uint8_t *buf);
|
||||
static herr_t H5S_point_serialize(const H5S_t *space, uint8_t **p);
|
||||
static herr_t H5S_point_deserialize(H5S_t *space, const uint8_t **p);
|
||||
static herr_t H5S_point_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
|
||||
static herr_t H5S_point_offset(const H5S_t *space, hsize_t *off);
|
||||
static htri_t H5S_point_is_contiguous(const H5S_t *space);
|
||||
@ -804,9 +804,11 @@ H5S_point_serial_size (const H5S_t *space)
|
||||
PURPOSE
|
||||
Serialize the current selection into a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_point_serialize(space, buf)
|
||||
H5S_t *space; IN: Dataspace pointer of selection to serialize
|
||||
uint8 *buf; OUT: Buffer to put serialized selection into
|
||||
herr_t H5S_point_serialize(space, p)
|
||||
const H5S_t *space; IN: Dataspace with selection to serialize
|
||||
uint8_t **p; OUT: Pointer to buffer to put serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -818,7 +820,7 @@ H5S_point_serial_size (const H5S_t *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_point_serialize (const H5S_t *space, uint8_t *buf)
|
||||
H5S_point_serialize (const H5S_t *space, uint8_t **p)
|
||||
{
|
||||
H5S_pnt_node_t *curr; /* Point information nodes */
|
||||
uint8_t *lenp; /* pointer to length location for later storage */
|
||||
@ -830,18 +832,18 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
|
||||
HDassert(space);
|
||||
|
||||
/* Store the preamble information */
|
||||
UINT32ENCODE(buf, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(buf, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(buf, (uint32_t)0); /* Store the un-used padding */
|
||||
lenp=buf; /* keep the pointer to the length location for later */
|
||||
buf+=4; /* skip over space for length */
|
||||
UINT32ENCODE(*p, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
|
||||
UINT32ENCODE(*p, (uint32_t)1); /* Store the version number */
|
||||
UINT32ENCODE(*p, (uint32_t)0); /* Store the un-used padding */
|
||||
lenp=*p; /* keep the pointer to the length location for later */
|
||||
*p+=4; /* skip over space for length */
|
||||
|
||||
/* Encode number of dimensions */
|
||||
UINT32ENCODE(buf, (uint32_t)space->extent.rank);
|
||||
UINT32ENCODE(*p, (uint32_t)space->extent.rank);
|
||||
len+=4;
|
||||
|
||||
/* Encode number of elements */
|
||||
UINT32ENCODE(buf, (uint32_t)space->select.num_elem);
|
||||
UINT32ENCODE(*p, (uint32_t)space->select.num_elem);
|
||||
len+=4;
|
||||
|
||||
/* Encode each point in selection */
|
||||
@ -852,7 +854,7 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
|
||||
|
||||
/* Encode each point */
|
||||
for(u=0; u<space->extent.rank; u++)
|
||||
UINT32ENCODE(buf, (uint32_t)curr->pnt[u]);
|
||||
UINT32ENCODE(*p, (uint32_t)curr->pnt[u]);
|
||||
|
||||
curr=curr->next;
|
||||
} /* end while */
|
||||
@ -870,9 +872,12 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
|
||||
PURPOSE
|
||||
Deserialize the current selection from a user-provided buffer.
|
||||
USAGE
|
||||
herr_t H5S_point_deserialize(space, buf)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place selection into
|
||||
uint8 *buf; IN: Buffer to retrieve serialized selection from
|
||||
herr_t H5S_point_deserialize(space, p)
|
||||
H5S_t *space; IN/OUT: Dataspace pointer to place
|
||||
selection into
|
||||
uint8 **p; OUT: Pointer to buffer holding serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -884,10 +889,10 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
static herr_t
|
||||
H5S_point_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
H5S_point_deserialize (H5S_t *space, const uint8_t **p)
|
||||
{
|
||||
H5S_seloper_t op=H5S_SELECT_SET; /* Selection operation */
|
||||
uint32_t rank; /* Rank of points */
|
||||
unsigned rank; /* Rank of points */
|
||||
size_t num_elem=0; /* Number of elements in selection */
|
||||
hsize_t *coord=NULL, *tcoord; /* Pointer to array of elements */
|
||||
unsigned i, j; /* local counting variables */
|
||||
@ -897,14 +902,13 @@ H5S_point_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
|
||||
/* Check args */
|
||||
HDassert(space);
|
||||
HDassert(buf);
|
||||
HDassert(p);
|
||||
HDassert(*p);
|
||||
|
||||
/* Deserialize points to select */
|
||||
buf += 16; /* Skip over selection header */
|
||||
UINT32DECODE(buf, rank); /* decode the rank of the point selection */
|
||||
if(rank != space->extent.rank)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of pointer does not match dataspace")
|
||||
UINT32DECODE(buf, num_elem); /* decode the number of points */
|
||||
/* (The header and rank have already beed decoded) */
|
||||
rank = space->extent.rank; /* Retrieve rank from space */
|
||||
UINT32DECODE(*p, num_elem); /* decode the number of points */
|
||||
|
||||
/* Allocate space for the coordinates */
|
||||
if(NULL == (coord = (hsize_t *)H5MM_malloc(num_elem * rank * sizeof(hsize_t))))
|
||||
@ -913,7 +917,7 @@ H5S_point_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
/* Retrieve the coordinates from the buffer */
|
||||
for(tcoord = coord, i = 0; i < num_elem; i++)
|
||||
for(j = 0; j < (unsigned)rank; j++, tcoord++)
|
||||
UINT32DECODE(buf, *tcoord);
|
||||
UINT32DECODE(*p, *tcoord);
|
||||
|
||||
/* Select points */
|
||||
if(H5S_select_elements(space, op, num_elem, (const hsize_t *)coord) < 0)
|
||||
|
||||
@ -206,7 +206,7 @@ H5_DLL int H5S_extent_get_dims(const H5S_extent_t *ext, hsize_t dims[], hsize_t
|
||||
H5_DLL htri_t H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2);
|
||||
|
||||
/* Operations on selections */
|
||||
H5_DLL herr_t H5S_select_deserialize(H5S_t *space, const uint8_t *buf);
|
||||
H5_DLL herr_t H5S_select_deserialize(H5S_t **space, const uint8_t **p);
|
||||
H5_DLL H5S_sel_type H5S_get_select_type(const H5S_t *space);
|
||||
H5_DLL herr_t H5S_select_iterate(void *buf, hid_t type_id, const H5S_t *space,
|
||||
H5D_operator_t op, void *operator_data);
|
||||
@ -227,7 +227,7 @@ H5_DLL herr_t H5S_select_get_seq_list(const H5S_t *space, unsigned flags,
|
||||
H5S_sel_iter_t *iter, size_t maxseq, size_t maxbytes,
|
||||
size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len);
|
||||
H5_DLL hssize_t H5S_select_serial_size(const H5S_t *space);
|
||||
H5_DLL herr_t H5S_select_serialize(const H5S_t *space, uint8_t *buf);
|
||||
H5_DLL herr_t H5S_select_serialize(const H5S_t *space, uint8_t **p);
|
||||
H5_DLL htri_t H5S_select_is_contiguous(const H5S_t *space);
|
||||
H5_DLL htri_t H5S_select_is_single(const H5S_t *space);
|
||||
H5_DLL htri_t H5S_select_is_regular(const H5S_t *space);
|
||||
|
||||
@ -239,9 +239,11 @@ H5S_select_serial_size(const H5S_t *space)
|
||||
PURPOSE
|
||||
Serialize the selection for a dataspace into a buffer
|
||||
USAGE
|
||||
herr_t H5S_select_serialize(space, buf)
|
||||
herr_t H5S_select_serialize(space, p)
|
||||
const H5S_t *space; IN: Dataspace with selection to serialize
|
||||
uint8_t *buf; OUT: Buffer to put serialized selection
|
||||
uint8_t **p; OUT: Pointer to buffer to put serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -256,17 +258,17 @@ H5S_select_serial_size(const H5S_t *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
herr_t
|
||||
H5S_select_serialize(const H5S_t *space, uint8_t *buf)
|
||||
H5S_select_serialize(const H5S_t *space, uint8_t **p)
|
||||
{
|
||||
herr_t ret_value=SUCCEED; /* Return value */
|
||||
|
||||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||||
|
||||
HDassert(space);
|
||||
HDassert(buf);
|
||||
HDassert(p);
|
||||
|
||||
/* Call the selection type's serialize function */
|
||||
ret_value=(*space->select.type->serialize)(space,buf);
|
||||
ret_value=(*space->select.type->serialize)(space,p);
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
} /* end H5S_select_serialize() */
|
||||
@ -428,9 +430,13 @@ H5S_select_valid(const H5S_t *space)
|
||||
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
|
||||
herr_t H5S_select_deserialize(space, p)
|
||||
H5S_t **space; IN/OUT: Dataspace pointer to place
|
||||
selection into. Will be allocated if not
|
||||
provided.
|
||||
uint8 **p; OUT: Pointer to buffer holding serialized
|
||||
selection. Will be advanced to end of
|
||||
serialized selection.
|
||||
RETURNS
|
||||
Non-negative on success/Negative on failure
|
||||
DESCRIPTION
|
||||
@ -444,42 +450,81 @@ H5S_select_valid(const H5S_t *space)
|
||||
REVISION LOG
|
||||
--------------------------------------------------------------------------*/
|
||||
herr_t
|
||||
H5S_select_deserialize (H5S_t *space, const uint8_t *buf)
|
||||
H5S_select_deserialize (H5S_t **space, const uint8_t **p)
|
||||
{
|
||||
const uint8_t *tbuf; /* Temporary pointer to the selection type */
|
||||
uint32_t sel_type; /* Pointer to the selection type */
|
||||
H5S_t *tmp_space; /* Pointer to actual dataspace to use, either
|
||||
*space or a newly allocated one */
|
||||
uint32_t sel_type; /* Pointer to the selection type */
|
||||
herr_t ret_value=FAIL; /* return value */
|
||||
|
||||
FUNC_ENTER_NOAPI(FAIL)
|
||||
|
||||
HDassert(space);
|
||||
|
||||
tbuf=buf;
|
||||
UINT32DECODE(tbuf, sel_type);
|
||||
/* Allocate space if not provided */
|
||||
if(!*space) {
|
||||
if(NULL == (tmp_space = H5S_create(H5S_SIMPLE)))
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create dataspace")
|
||||
} /* end if */
|
||||
else
|
||||
tmp_space = *space;
|
||||
|
||||
/* Decode selection type */
|
||||
UINT32DECODE(*p, sel_type);
|
||||
|
||||
/* Skip over the remainder of the header */
|
||||
*p += 12;
|
||||
|
||||
/* Decode and check or patch rank for point and hyperslab selections */
|
||||
if((sel_type == H5S_SEL_POINTS) || (sel_type == H5S_SEL_HYPERSLABS)) {
|
||||
uint32_t rank; /* Rank of dataspace */
|
||||
|
||||
/* Decode the rank of the point selection */
|
||||
UINT32DECODE(*p,rank);
|
||||
|
||||
if(!*space)
|
||||
/* Patch the rank of the allocated dataspace */
|
||||
tmp_space->extent.rank = rank;
|
||||
else
|
||||
/* Verify the rank of the provided dataspace */
|
||||
if(rank != tmp_space->extent.rank)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of serialized selection does not match dataspace")
|
||||
} /* end if */
|
||||
|
||||
/* Make routine for selection type */
|
||||
switch(sel_type) {
|
||||
case H5S_SEL_POINTS: /* Sequence of points selected */
|
||||
ret_value=(*H5S_sel_point->deserialize)(space,buf);
|
||||
ret_value = (*H5S_sel_point->deserialize)(tmp_space, p);
|
||||
break;
|
||||
|
||||
case H5S_SEL_HYPERSLABS: /* Hyperslab selection defined */
|
||||
ret_value=(*H5S_sel_hyper->deserialize)(space,buf);
|
||||
ret_value = (*H5S_sel_hyper->deserialize)(tmp_space, p);
|
||||
break;
|
||||
|
||||
case H5S_SEL_ALL: /* Entire extent selected */
|
||||
ret_value=(*H5S_sel_all->deserialize)(space,buf);
|
||||
ret_value = (*H5S_sel_all->deserialize)(tmp_space, p);
|
||||
break;
|
||||
|
||||
case H5S_SEL_NONE: /* Nothing selected */
|
||||
ret_value=(*H5S_sel_none->deserialize)(space,buf);
|
||||
ret_value = (*H5S_sel_none->deserialize)(tmp_space, p);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(ret_value<0)
|
||||
if(ret_value < 0)
|
||||
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTLOAD, FAIL, "can't deserialize selection")
|
||||
|
||||
/* Return space to the caller if allocated */
|
||||
if(!*space)
|
||||
*space = tmp_space;
|
||||
|
||||
done:
|
||||
/* Free temporary space if not passed to caller (only happens on error) */
|
||||
if(!*space && tmp_space)
|
||||
if(H5S_close(tmp_space) < 0)
|
||||
HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace")
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
} /* H5S_select_deserialize() */
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user