//--------------------------------------------------------------------------
// Function: FileAccPropList::setGcReferences
///\brief Sets garbage collecting references flag.
///\param gc_ref - IN: Flag setting reference garbage collection to
/// on (1) or off (0).
///\exception H5::PropListIException
///\par Description
/// For detail on \a fapl, please refer to
/// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetGCReferences
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void FileAccPropList::setGcReferences( unsigned gc_ref ) const
{
herr_t ret_value = H5Pset_gc_references( id, gc_ref );
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setGcReferences", "H5Pset_gc_references failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setFcloseDegree
///\brief Sets the degree for the file close behavior.
///\param degree - IN:
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setFcloseDegree(H5F_close_degree_t degree)
{
herr_t ret_value = H5Pset_fclose_degree(id, degree);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setFcloseDegree", "H5Pset_fclose_degree failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setSec2
///\brief Modifies this file access property list to use the sec2
/// driver.
///
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setSec2() const
{
herr_t ret_value = H5Pset_fapl_sec2(id);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setSec2", "H5Pset_fapl_sec2 failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::getLibverBounds
///\brief Gets the current settings for the library version format bounds
/// from a file access property list.
///\param libver_low - OUT: Earliest version of the library that will be
/// used for creating or writing objects
///\param libver_high - OUT: Latest version of the library that will be
/// used for creating or writing objects
///\exception H5::PropListIException
///\par Description
/// On success, the argument \a libver_low can have the following
/// values:
/// \li \c H5F_LIBVER_EARLIEST
/// \li \c H5F_LIBVER_18
/// \li \c H5F_LIBVER_LATEST
///
/// and \a libver_high:
/// \li \c H5F_LIBVER_18
/// \li \c H5F_LIBVER_LATEST
// Programmer: Binh-Minh Ribler - March, 2015
//--------------------------------------------------------------------------
void FileAccPropList::getLibverBounds(H5F_libver_t& libver_low, H5F_libver_t& libver_high) const
{
herr_t ret_value = H5Pget_libver_bounds(id, &libver_low, &libver_high);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::getLibverBounds", "H5Pget_libver_bounds failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setMetaBlockSize
///\brief Sets the minimum size of metadata block allocations.
///\param block_size - IN: Minimum size, in bytes, of metadata
/// block allocations
///\exception H5::PropListIException
///\par Description
/// For more detail, please see the C layer Reference Manual at:
/// <A HREF="../RM_H5P.html#Property-SetMetaBlockSize">../RM_H5P.html#Property-SetMetaBlockSize</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setMetaBlockSize(hsize_t &block_size) const
{
herr_t ret_value = H5Pset_meta_block_size(id, block_size);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setMetaBlockSize", "H5Pset_meta_block_size failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setLog
///\brief Modifies this file access property list to use the logging
/// driver.
///\param logfile - IN: Name of the log file
///\param flags - IN: Flags specifying the types of logging activity
///\param buf_size - IN: Size of the logging buffer
///\exception H5::PropListIException
///\par Description
/// For detail on \a flags, please refer to
/// <A HREF="../RM_H5P.html#Property-SetFaplStream">../RM_H5P.html#Property-SetFaplStream</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setLog(const char *logfile, unsigned flags, size_t buf_size) const
{
herr_t ret_value = H5Pset_fapl_log(id, logfile, flags, buf_size);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setLog", "H5Pset_fapl_log failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setStream
///\brief Modifies this file access property list to use the Stream
/// driver.
///\param fapl - IN: The streaming I/O file access property list
///\exception H5::PropListIException
///\par Description
/// For detail on \a fapl, please refer to
/// <A HREF="../RM_H5P.html#Property-SetFaplStream">../RM_H5P.html#Property-SetFaplStream</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setStream(H5FD_stream_fapl_t &fapl) const
{
herr_t ret_value = H5Pset_fapl_stream (id, &fapl);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setStream", "H5Pset_fapl_stream failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setSieveBufSize
///\brief Sets the maximum size of the data sieve buffer.
///\param bufsize - IN: Maximum size, in bytes, of data sieve buffer
///\exception H5::PropListIException
///\par Description
/// For detail on data sieving, please refer to
/// <A HREF="../RM_H5P.html#Property-SetSieveBufSize">../RM_H5P.html#Property-SetFaplStream../RM_H5P.html#Property-SetFaplStream</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setSieveBufSize(size_t bufsize) const
{
herr_t ret_value = H5Pset_sieve_buf_size(id, bufsize);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::getSieveBufSize", "H5Pget_sieve_buf_size failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::getCore
///\brief Queries core file driver properties.
///\param increment - OUT: Size of memory increment, in bytes
///\param backing_store - OUT: Indicating whether to write the file
/// contents to disk when the file is closed
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::getCore (size_t& increment, hbool_t& backing_store) const
{
herr_t ret_value = H5Pget_fapl_core(id, &increment, &backing_store);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::getCore", "H5Pget_fapl_core failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setFamily
///\brief Sets this file access property list to use the family driver.
///\param memb_size - IN: Size in bytes of each file member
///\param memb_plist - IN: File access property list to be used for
/// each family member
///\exception H5::PropListIException
///\par Description
/// Note that \a memb_size is used only when creating a new file.
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setFamily( hsize_t memb_size, const FileAccPropList& memb_plist ) const
{
herr_t ret_value = H5Pset_fapl_family (id, memb_size, memb_plist.getId() );
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setFamily", "H5Pset_fapl_family failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setFamilyOffset
///\brief Sets offset for family driver.
///\param offset - IN: offset value
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setFamilyOffset(hsize_t offset) const
{
herr_t ret_value = H5Pset_family_offset(id, offset);
if (ret_value < 0)
{
throw PropListIException("FileAccPropList::setFamilyOffset", "H5Pset_family_offset failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setDriver
///\brief Set file driver for this property list.
///\param new_driver_id - IN: File driver
///\param new_driver_info - IN: Struct containing the driver-specific properites
///\exception H5::PropListIException
///\par Description
/// For a list of valid driver identifiers, please see the C
/// layer Reference Manual at:
/// <A HREF="../RM_H5P.html#Property-GetDriver">../RM_H5P.html#Property-GetDriver</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setDriver(hid_t new_driver_id, const void *new_driver_info) const
{
herr_t ret_value = H5Pset_driver(id, new_driver_id, new_driver_info);
if (ret_value < 0)
{
throw PropListIException("FileAccPropList::setDriver", "H5Pset_driver failed");
}
}
//--------------------------------------------------------------------------
// Function: ObjCreatPropList::setAttrCrtOrder
///\brief Sets tracking and indexing of attribute creation order.
///\param crt_order_flags - IN: Flags specifying whether to track and
/// index attribute creation order. Default: No flag set
///\exception H5::PropListIException
///\par Description
/// Valid flags are:
/// \li \c H5P_CRT_ORDER_TRACKED - Attribute creation order is tracked
/// \li \c H5P_CRT_ORDER_INDEXED - Attribute creation order is
/// indexed (requires H5P_CRT_ORDER_TRACKED).
/// When no flag is set, attribute creation order is neither
/// tracked not indexed. Note that HDF5 currently provides no
/// mechanism to turn on attribute creation order tracking at object
/// creation time and to build the index later.
/// The C layer Reference Manual at can be found at:
/// https://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetAttrCreationOrder
// Programmer: Binh-Minh Ribler - September 2015
//--------------------------------------------------------------------------
void ObjCreatPropList::setAttrCrtOrder(unsigned crt_order_flags) const
{
herr_t ret_value = H5Pset_attr_creation_order(id, crt_order_flags);
if (ret_value < 0)
{
throw PropListIException("ObjCreatPropList::setAttrCrtOrder", "H5Pset_attr_creation_order failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetCreatPropList::setChunk
///\brief Sets the size of the chunks used to store a chunked layout
/// dataset.
///\param ndims - IN: Number of dimensions of each chunk
///\param dim - IN: Array containing the size of each chunk
///\exception H5::PropListIException
///\par Description
/// The \a ndims parameter currently must have the same value as
/// the rank of the dataset. The values of the \a dim array
/// define the size of the chunks to store the dataset's raw
/// data. As a side-effect, the layout of the dataset will be
/// changed to \c H5D_CHUNKED, if it is not so already.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetCreatPropList::setChunk( int ndims, const hsize_t* dim ) const
{
herr_t ret_value = H5Pset_chunk( id, ndims, dim );
if( ret_value < 0 )
{
throw PropListIException("DSetCreatPropList::setChunk", "H5Pset_chunk failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::getAlignment
///\brief Returns the current settings for alignment properties from
/// this property list.
///\param threshold - OUT: Retrieved threshold value for file object size
///\param alignment - OUT: Retrieved alignment value
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void FileAccPropList::getAlignment( hsize_t &threshold, hsize_t &alignment ) const
{
herr_t ret_value = H5Pget_alignment( id, &threshold, &alignment );
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::getAlignment", "H5Pget_alignment failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setMultiType
///\brief Sets data type for \c MULTI driver.
///\param dtype - IN: Type of data
///\exception H5::PropListIException
///\par Description
/// More details and valid values for \a dtype can be found at:
/// <A HREF="../RM_H5P.html#Property-SetMultiType">../RM_H5P.html#Property-SetMultiType</A>
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void FileAccPropList::setMultiType(H5FD_mem_t dtype) const
{
herr_t ret_value = H5Pset_multi_type(id, dtype);
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setMultiType", "H5Pset_multi_type failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::setCache
///\brief Sets the meta data cache and raw data chunk cache parameters.
///\param mdc_nelmts - IN: Number of elements in the meta data cache
///\param rdcc_nelmts - IN: Number of elements in the raw data chunk cache
///\param rdcc_nbytes - IN: Total size of the raw data chunk cache, in bytes
///\param rdcc_w0 - IN: Preemption policy
///\exception H5::PropListIException
///\par Description
/// The argument \a rdcc_w0 should hold a value between 0 and 1
/// inclusive. This value indicates how much chunks that have
/// been fully read are favored for preemption. A value of zero
/// means fully read chunks are treated no differently than other
/// chunks (the preemption is strictly LRU) while a value of one
/// means fully read chunks are always preempted before other chunks.
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void FileAccPropList::setCache( int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const
{
herr_t ret_value = H5Pset_cache( id, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0 );
if( ret_value < 0 )
{
throw PropListIException("FileAccPropList::setCache", "H5Pset_cache failed");
}
}
//--------------------------------------------------------------------------
// Function: ObjCreatPropList::setAttrPhaseChange
///\brief Sets attribute storage phase change thresholds.
///\param max_compact - IN: Maximum number of attributes to be stored in
/// compact storage. Default to 8
///\param min_dense - IN: Minimum number of attributes to be stored in
/// dense storage. Default to 6
///\exception H5::PropListIException
///\par Description
/// If \c max_compact is set to 0, dense storage will be used.
/// For more detail about on attribute storage, please refer to the
/// C layer Reference Manual at:
/// https://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetAttrPhaseChange
// Programmer: Binh-Minh Ribler - September 2015
//--------------------------------------------------------------------------
void ObjCreatPropList::setAttrPhaseChange(unsigned max_compact, unsigned min_dense) const
{
herr_t ret_value = H5Pset_attr_phase_change(id, max_compact, min_dense);
if (ret_value < 0)
{
throw PropListIException("ObjCreatPropList::setAttrPhaseChange", "H5Pset_attr_phase_change failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setSmallDataBlockSize
///\brief Sets the size of a contiguous block reserved for small data.
///\param size - IN: Maximum size, in bytes, of the small data block.
///\exception H5::PropListIException
///\par Description
/// For detail, please refer to the C layer Reference Manual at:
/// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetSmallData
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void DSetMemXferPropList::setSmallDataBlockSize(hsize_t size)
{
herr_t ret_value = H5Pset_small_data_block_size(id, size);
if (ret_value < 0)
{
throw PropListIException("DSetMemXferPropList::setSmallDataBlockSize",
"H5Pset_small_data_block_size failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::getVlenMemManager
///\brief Gets the memory manager for variable-length datatype allocation
///\param alloc_func - OUT: User's allocate routine
///\param alloc_info - OUT: User's allocation parameters
///\param free_func - OUT: User's free routine
///\param free_info - OUT: User's free parameters
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetMemXferPropList::getVlenMemManager( H5MM_allocate_t& alloc_func, void** alloc_info, H5MM_free_t& free_func, void** free_info ) const
{
herr_t ret_value = H5Pget_vlen_mem_manager( id, &alloc_func, alloc_info, &free_func, free_info );
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::getVlenMemManager",
"H5Pget_vlen_mem_manager failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::getTypeConvCB
///\brief Gets the exception handling callback function and data.
///\param op - IN: Retrieved user function
///\param user_data - IN: Retrieved user data
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void DSetMemXferPropList::getTypeConvCB( H5T_conv_except_func_t *op, void **user_data) const
{
herr_t ret_value = H5Pget_type_conv_cb( id, op, user_data);
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::getTypeConvCB",
"H5Pget_type_conv_cb failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setDataTransform
///\brief Sets data transform expression.
///\param expression - IN: null-terminated data transform expression (char*)
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - Mar, 2014
//--------------------------------------------------------------------------
void DSetMemXferPropList::setDataTransform(const char* expression) const
{
herr_t ret_value = H5Pset_data_transform( id, expression);
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::setDataTransform",
"H5Pset_data_transform failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::getBtreeRatios
///\brief Gets B-tree split ratios for a dataset transfer property list.
///\param left - OUT: B-tree split ratio for left-most nodes
///\param middle - OUT: B-tree split ratio for right-most nodes and lone nodes
///\param right - OUT: B-tree split ratio for all other nodes
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetMemXferPropList::getBtreeRatios( double& left, double& middle, double& right ) const
{
herr_t ret_value = H5Pget_btree_ratios( id, &left, &middle, &right );
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::getBtreeRatios",
"H5Pget_btree_ratios failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setBtreeRatios
///\brief Sets B-tree split ratios for a dataset transfer property list.
///\param left - IN: B-tree split ratio for left-most nodes
///\param middle - IN: B-tree split ratio for right-most nodes and lone nodes
///\param right - IN: B-tree split ratio for all other nodes
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetMemXferPropList::setBtreeRatios( double left, double middle, double right ) const
{
herr_t ret_value = H5Pset_btree_ratios( id, left, middle, right );
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::setBtreeRatios",
"H5Pset_btree_ratios failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setPreserve
///\brief Sets the dataset transfer property list status to true or false.
///\param status - IN: Status to set, true or false
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetMemXferPropList::setPreserve( bool status ) const
{
herr_t ret_value = H5Pset_preserve( id, (hbool_t) status );
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::setPreserve",
"H5Pset_preserve failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setBuffer
///\brief Sets type conversion and background buffers.
///\param size - IN: Size, in bytes, of the type conversion and background buffers
///\param tconv - IN: Pointer to application-allocated type conversion buffer
///\param bkg - IN: Pointer to application-allocated background buffer
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetMemXferPropList::setBuffer( size_t size, void* tconv, void* bkg ) const
{
herr_t ret_value = H5Pset_buffer( id, size, tconv, bkg );
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::setBuffer",
"H5Pset_buffer failed");
}
}
//--------------------------------------------------------------------------
// Function: FileAccPropList::getDriver
///\brief Return the ID of the low-level file driver.
///\return A low-level driver ID which is the same ID used when the
/// driver was set for the property list. The driver ID is
/// only valid as long as the file driver remains registered.
/// Valid driver identifiers can be found at:
/// <A HREF="../RM_H5P.html#Property-GetDriver">../RM_H5P.html#Property-GetDriver</A>
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
hid_t FileAccPropList::getDriver() const
{
hid_t driver = H5Pget_driver(id);
if (driver < 0)
{
throw PropListIException("FileAccPropList::getDriver", "H5Pget_driver failed");
}
return(driver);
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setHyperVectorSize
///\brief Sets number of I/O vectors to be read/written in hyperslab I/O.
///
///\exception H5::PropListIException
///\par Description
/// For information, please refer to the C layer Reference
/// Manual at:
/// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetHyperVectorSize
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void DSetMemXferPropList::setHyperVectorSize(size_t vector_size)
{
herr_t ret_value = H5Pset_hyper_vector_size(id, vector_size);
if (ret_value < 0)
{
throw PropListIException("DSetMemXferPropList::setHyperVectorSize",
"H5Pset_hyper_vector_size failed");
}
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::setEDCCheck
///\brief Enables or disables error-detecting for a dataset reading
/// process.
///\param check - IN: Specifies whether error detection is enabled or
/// disabled
///\exception H5::PropListIException
///\par Description
/// The error detection algorithm used is the algorithm previously
/// specified in the corresponding dataset creation property
/// list. This function does not affect the use of error
/// detection in the writing process.
///\par
/// Valid values are as follows:
/// \li \c H5Z_ENABLE_EDC (default)
/// \li \c H5Z_DISABLE_EDC
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
void DSetMemXferPropList::setEDCCheck(H5Z_EDC_t check)
{
herr_t ret_value = H5Pset_edc_check(id, check);
if (ret_value < 0)
{
throw PropListIException("DSetMemXferPropList::setEDCCheck",
"H5Pset_edc_check failed");
}
}
//--------------------------------------------------------------------------
// Function: LinkAccPropList::setNumLinks
///\brief Set the number of soft or user-defined link traversals allowed
/// before the library assumes it has found a cycle and aborts the
/// traversal.
///
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - March 1, 2017
//--------------------------------------------------------------------------
void LinkAccPropList::setNumLinks(size_t nlinks) const
{
herr_t ret_value = H5Pset_nlinks(id, nlinks);
// Throw exception if H5Pset_nlinks returns failure
if (ret_value < 0)
{
throw PropListIException("setNumLinks", "H5Pset_nlinks failed");
}
}
