//-------------------------------------------------------------------------- // 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"); } }