* | \c mem_space_id |
* \c file_space_id |
* Behavior |
|---|
* | valid dataspace ID |
* valid dataspace ID |
* \p mem_space_id specifies the memory dataspace and the
* selection within it. \p file_space_id specifies the
* selection within the file dataset's dataspace. |
* | #H5S_ALL |
* valid dataspace ID |
* The file dataset's dataspace is used for the memory
* dataspace and the selection specified with \p file_space_id
* specifies the selection within it. The combination of the
* file dataset's dataspace and the selection from \p
* file_space_id is used for memory also. valid dataspace
* ID |
* | valid dataspace ID |
* #H5S_ALL |
* \p mem_space_id specifies the memory dataspace and the
* selection within it. The selection within the file
* dataset's dataspace is set to "all" selection. |
* | #H5S_ALL |
* #H5S_ALL |
* The file dataset's dataspace is used for the memory
* dataspace and the selection within the memory dataspace is
* set to the "all" selection. The selection within the file
* dataset's dataspace is set to the "all"
* selection. |
*
* Setting an "all" selection indicates that the entire dataspace,
* as defined by the current dimensions of a dataspace, will
* be selected. The number of elements selected in the memory
* dataspace must match the number of elements selected in the
* file dataspace.
*
* \p dxpl_id can be the constant #H5P_DEFAULT, in which
* case the default data transfer properties are used.
*
* Writing to a dataset will fail if the HDF5 file was not opened
* with write access permissions.
*
* If the dataset's space allocation time is set to
* #H5D_ALLOC_TIME_LATE or #H5D_ALLOC_TIME_INCR and the space for
* the dataset has not yet been allocated, that space is allocated
* when the first raw data is written to the dataset. Unused space
* in the dataset will be written with fill values at the same
* time if the dataset's fill time is set to #H5D_FILL_TIME_IFSET
* or #H5D_FILL_TIME_ALLOC.
*
* \attention If a dataset's storage layout is 'compact', care must be
* taken when writing data to the dataset in parallel. A compact
* dataset's raw data is cached in memory and may be flushed
* to the file from any of the parallel processes, so parallel
* applications should always attempt to write identical data to
* the dataset from all processes.
*
* \see H5Pset_fill_time(), H5Pset_alloc_time()
*
*/
H5_DLL herr_t H5Dwrite(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id,
hid_t dxpl_id, const void *buf);
/**
* --------------------------------------------------------------------------
* \ingroup H5D
*
* \brief Asynchronous version of H5Dwrite()
*
* \app_file
* \app_func
* \app_line
* \param[in] dset_id Identifier of the dataset to read from
* \param[in] mem_type_id Identifier of the memory datatype
* \param[in] mem_space_id Identifier of the memory dataspace
* \param[in] file_space_id Identifier of the dataset's dataspace in the file
* \dxpl_id
* \param[out] buf Buffer with data to be written to the file
* \es_id
*
* \return \herr_t
*
* \see H5Dwrite()
*
*/
H5_DLL herr_t H5Dwrite_async(const char *app_file, const char *app_func, unsigned app_line, hid_t dset_id,
hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t dxpl_id,
const void *buf, hid_t es_id);
/**
* --------------------------------------------------------------------------
* \ingroup H5D
*
* \brief Writes a raw data chunk from a buffer directly to a dataset in a file
*
* \dset_id
* \dxpl_id
* \param[in] filters Mask for identifying the filters in use
* \param[in] offset Logical position of the chunk’s first element in the
* dataspace
* \param[in] data_size Size of the actual data to be written in bytes
* \param[in] buf Buffer containing data to be written to the chunk
*
* \return \herr_t
*
* \details H5Dwrite_chunk() writes a raw data chunk as specified
* by its logical offset \p offset in a chunked dataset \p dset_id
* from the application memory buffer \p buf to the dataset in
* the file. Typically, the data in \p buf is preprocessed in
* memory by a custom transformation, such as compression. The
* chunk will bypass the library’s internal data transfer
* pipeline, including filters, and will be written directly to
* the file. Only one chunk can be written with this function.
*
* H5Dwrite_chunk() replaces the now deprecated H5DOwrite_chunk()
* function, which was located in the high level optimization
* library. The parameters and behavior are identical to the
* original.
*
* \p filters is a mask providing a record of which filters are
* used with the the chunk. The default value of the mask is
* zero (0), indicating that all enabled filters are applied. A
* filter is skipped if the bit corresponding to the filter’s
* position in the pipeline (0 ≤ position < 32) is turned on.
* This mask is saved with the chunk in the file.
*
* \p offset is an array specifying the logical position of the
* first element of the chunk in the dataset’s dataspace. The
* length of the offset array must equal the number of dimensions,
* or rank, of the dataspace. The values in offset must not exceed
* the dimension limits and must specify a point that falls on
* a dataset chunk boundary.
*
* \p data_size is the size in bytes of the chunk, representing
* the number of bytes to be read from the buffer \p buf. If the
* data chunk has been precompressed, \p data_size should be the
* size of the compressed data.
*
* \p buf is the memory buffer containing data to be written to
* the chunk in the file.
*
* \attention Exercise caution when using H5Dread_chunk() and
* H5Dwrite_chunk(), as they read and write data chunks directly
* in a file. H5Dwrite_chunk() bypasses hyperslab selection, the
* conversion of data from one datatype to another, and the filter
* pipeline to write the chunk. Developers should have experience
* with these processes before using this function. Please see
* Using the Direct Chunk Write Function for more information.
*
* \note H5Dread_chunk() and H5Dwrite_chunk() are not supported under
* parallel and do not support variable length types.
*
* \since 1.10.2
*
*/
H5_DLL herr_t H5Dwrite_chunk(hid_t dset_id, hid_t dxpl_id, uint32_t filters, const hsize_t *offset,
size_t data_size, const void *buf);
/**
* --------------------------------------------------------------------------
* \ingroup H5D
*
* \brief Reads a raw data chunk directly from a dataset in a file into
* a buffer
*
* \dset_id
* \dxpl_id
* \param[in] offset Logical position of the chunk’s first element in the
* dataspace
* \param[in,out] filters Mask for identifying the filters in use
* \param[out] buf Buffer containing data to be written to the chunk
*
* \return \herr_t
*
* \details H5Dread_chunk() reads a raw data chunk as specified by
* its logical offset \p offset in a chunked dataset \p dset_id
* from the dataset in the file into the application memory
* buffer \p buf. The data in \p buf is read directly from the
* file bypassing the library’s internal data transfer pipeline,
* including filters.
*
* \p offset is an array specifying the logical position of the
* first element of the chunk in the dataset’s dataspace. The
* length of the \p offset array must equal the number of dimensions,
* or rank, of the dataspace. The values in \p offset must not exceed
* the dimension limits and must specify a point that falls on
* a dataset chunk boundary.
*
* The mask \p filters indicates which filters are used with the
* chunk when written. A zero value indicates that all enabled
* filters are applied on the chunk. A filter is skipped if the
* bit corresponding to the filter’s position in the pipeline
* (0 ≤ position < 32) is turned on.
*
* \p buf is the memory buffer containing the chunk read from
* the dataset in the file.
*
* \attention Exercise caution when using H5Dread_chunk() and
* H5Dwrite_chunk(), as they read and write data chunks directly
* in a file. H5Dwrite_chunk() bypasses hyperslab selection, the
* conversion of data from one datatype to another, and the filter
* pipeline to write the chunk. Developers should have experience
* with these processes before using this function. Please see
* Using the Direct Chunk Write Function for more information.
*
* \note H5Dread_chunk() and H5Dwrite_chunk() are not supported under
* parallel and do not support variable length types.
*
* \since 1.10.2
*
*/
H5_DLL herr_t H5Dread_chunk(hid_t dset_id, hid_t dxpl_id, const hsize_t *offset, uint32_t *filters,
void *buf);
/**
* --------------------------------------------------------------------------
* \ingroup H5D
*
* \brief Iterates over all selected elements in a dataspace
*
* \param[in,out] buf Buffer containing the elements to iterate over
* \type_id
* \space_id
* \param[in] op Function pointer
* \param[in,out] operator_data User-defined data
*
* \return \success{The return value of the first operator that returns
* non-zero, or zero if all members were processed with no
* operator returning non-zero.}
* \return \failure{Negative if an error occurs in the library, or the negative
* value returned by one of the operators.}
*
* \details H5Diterate() iterates over all the data elements
* in the memory buffer \p buf, executing the callback function
* \p op once for each such data element.
*
* The prototype of the callback function \p op is as follows
* (as defined in the source code file H5Lpublic.h):
* \snippet this H5D_operator_t_snip
* The parameters of this callback function are:
*
*