mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r12404] Purpose: Fix typos/formats

Browse Source 
Description:
    Fixed typos and re-arranged some functions to be in sync with 1.6.

Platforms tested:
    Linux 2.4 (heping)
    SunOS 5.9 (shanti)
    AIX 5.1 (copper)
This commit is contained in:
Binh-Minh Ribler 2006-06-05 11:17:36 -05:00
parent f5a16e9bfa
commit 32d3e6f04f
38 changed files with 381 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
c++/src/H5AbstractDs.h
View File

@ -41,25 +41,25 @@ class H5_DLLCPP AbstractDs : public H5Object {
// etc..., use the specific functions, that follow, instead.
DataType getDataType() const;
// Gets a copy of the specific datatype of this abstract dataset.
// Gets a copy of the specific datatype of this abstract dataset.
ArrayType getArrayType() const;
CompType getCompType() const;
EnumType getEnumType() const;
IntType getIntType() const;
FloatType getFloatType() const;
StrType getStrType() const;
CompType getCompType() const;
EnumType getEnumType() const;
IntType getIntType() const;
FloatType getFloatType() const;
StrType getStrType() const;
VarLenType getVarLenType() const;
// Gets the dataspace of this abstract dataset - pure virtual.
virtual DataSpace getSpace() const = 0;
// Gets the class of the datatype that is used by this abstract
// Gets the class of the datatype that is used by this abstract
// dataset.
H5T_class_t getTypeClass() const;
// Returns the amount of storage size required for this abstract
// Returns the amount of storage size required for this abstract
// dataset - pure virtual.
virtual hsize_t getStorageSize() const = 0;
virtual hsize_t getStorageSize() const = 0;
// Copy constructor
AbstractDs( const AbstractDs& original );
@ -75,7 +75,7 @@ class H5_DLLCPP AbstractDs : public H5Object {
AbstractDs( const hid_t ds_id );
private:
// This member function is implemented by DataSet and Attribute
// This member function is implemented by DataSet and Attribute.
virtual hid_t p_get_type() const = 0;
};
#ifndef H5_NO_NAMESPACE

2
c++/src/H5ArrayType.cpp
View File

@ -164,7 +164,7 @@ ArrayType::~ArrayType()
{
// Free allocated memory
if (dimensions != NULL)
delete [] dimensions;
delete []dimensions;
}
#ifndef H5_NO_NAMESPACE

1
c++/src/H5ArrayType.h
View File

@ -22,6 +22,7 @@
#ifndef H5_NO_NAMESPACE
namespace H5 {
#endif
class H5_DLLCPP ArrayType : public DataType {
public:
// Constructor that creates a new array data type based on the

2
c++/src/H5AtomType.cpp
View File

@ -97,7 +97,7 @@ H5T_order_t AtomType::getOrder() const
//--------------------------------------------------------------------------
// Function: AtomType::getOrder
///\brief This is an overloaded member function, provided for convenience.
/// It takes a reference to a \c std::string for the buffer that
/// It takes a reference to a \c std::string for the buffer that
/// provide the text description of the returned byte order.
/// The text description can be either of the following:
/// "Little endian byte ordering (0)";

7
c++/src/H5AtomType.h
View File

@ -24,11 +24,12 @@
#ifndef H5_NO_NAMESPACE
namespace H5 {
#endif
class H5_DLLCPP AtomType : public DataType {
public:
// Returns the byte order of an atomic datatype.
H5T_order_t getOrder( H5std_string& order_string ) const;
H5T_order_t getOrder() const;
H5T_order_t getOrder( H5std_string& order_string ) const;
// Sets the byte ordering of an atomic datatype.
void setOrder( H5T_order_t order ) const;
@ -55,8 +56,8 @@ class H5_DLLCPP AtomType : public DataType {
// Sets the total size for an atomic datatype.
void setSize( size_t size ) const;
// Returns this class name
virtual H5std_string fromClass () const { return("AtomType"); }
// Returns this class name
virtual H5std_string fromClass () const { return("AtomType"); }
// Copy constructor - makes copy of the original object
AtomType( const AtomType& original );

37
c++/src/H5Attribute.cpp
View File

@ -17,7 +17,6 @@
#else
#include <iostream>
#endif
#include <string>
#include "H5Include.h"
@ -261,6 +260,21 @@ H5std_string Attribute::getName() const
return( attr_name );
}
//--------------------------------------------------------------------------
// Function: Attribute::getStorageSize
///\brief Returns the amount of storage size required for this attribute.
///\return Size of the storage or 0, for no data
///\exception H5::AttributeIException
// Note: H5Dget_storage_size returns 0 when there is no data. This
// function should have no failure. (from SLU)
// Programmer Binh-Minh Ribler - Mar, 2005
//--------------------------------------------------------------------------
hsize_t Attribute::getStorageSize() const
{
hsize_t storage_size = H5Aget_storage_size(id);
return (storage_size);
}
//--------------------------------------------------------------------------
// Function: Attribute::close
///\brief Closes this attribute.
@ -282,28 +296,15 @@ void Attribute::close()
}
}
//--------------------------------------------------------------------------
// Function: Attribute::getStorageSize
///\brief Returns the amount of storage size required for this attribute.
///\return Size of the storage or 0, for no data
///\exception H5::AttributeIException
// Note: H5Dget_storage_size returns 0 when there is no data. This
// function should have no failure. (from SLU)
// Programmer Binh-Minh Ribler - Mar, 2005
//--------------------------------------------------------------------------
hsize_t Attribute::getStorageSize() const
{
hsize_t storage_size = H5Aget_storage_size(id);
return (storage_size);
}
//--------------------------------------------------------------------------
// Function: Attribute destructor
///\brief Properly terminates access to this attribute.
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
Attribute::~Attribute()
{

12
c++/src/H5Attribute.h
View File

@ -53,6 +53,9 @@ class H5_DLLCPP Attribute : public AbstractDs {
// Copy constructor: makes a copy of an existing Attribute object.
Attribute( const Attribute& original );
// Default constructor
Attribute();
// Destructor: properly terminates access to this attribute.
virtual ~Attribute();
@ -63,14 +66,11 @@ class H5_DLLCPP Attribute : public AbstractDs {
// sub-types
virtual hid_t p_get_type() const;
// do not inherit iterateAttrs from H5Object
// do not inherit H5Object::iterateAttrs
int iterateAttrs() { return 0; }
// do not inherit iterateAttrs from H5Object
void rename() {}
// Default constructor
Attribute();
// do not inherit H5Object::renameAttr
void renameAttr() {}
};
#ifndef H5_NO_NAMESPACE
}

18
c++/src/H5CommonFG.cpp
View File

@ -56,7 +56,7 @@ namespace H5 {
///\param size_hint - IN: Indicates the number of bytes to reserve for
/// the names that will appear in the group
///\return Group instance
///\exception H5::GroupIException
///\exception H5::FileIException or H5::GroupIException
///\par Description
/// The optional \a size_hint specifies how much file space to
/// reserve for storing the names that will appear in this new
@ -99,7 +99,7 @@ Group CommonFG::createGroup( const H5std_string& name, size_t size_hint ) const
/// or another group.
///\param name - IN: Name of the group to open
///\return Group instance
///\exception H5::GroupIException
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Group CommonFG::openGroup( const char* name ) const
@ -139,7 +139,7 @@ Group CommonFG::openGroup( const H5std_string& name ) const
///\param data_space - IN: Dataspace for the dataset
///\param create_plist - IN: Creation properly list for the dataset
///\return DataSet instance
///\exception H5::DataSetIException
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
DataSet CommonFG::createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist ) const
@ -180,7 +180,7 @@ DataSet CommonFG::createDataSet( const H5std_string& name, const DataType& data_
///\brief Opens an existing dataset at this location.
///\param name - IN: Name of the dataset to open
///\return DataSet instance
///\exception H5::DataSetIException
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
DataSet CommonFG::openDataSet( const char* name ) const
@ -318,11 +318,11 @@ void CommonFG::move( const H5std_string& src, const H5std_string& dst ) const
///\param follow_link - IN: Link flag
///\param statbuf - OUT: Buffer to return information about the object
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
///\par Description
/// For more information, please refer to the C layer Reference
/// Manual at:
/// http://hdf.ncsa.uiuc.edu/HDF5/doc/RM_H5G.html#Group-GetObjinfo
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CommonFG::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const
{
@ -505,7 +505,7 @@ H5std_string CommonFG::getComment (const H5std_string& name) const
{
throwException("getComment", "H5Gget_comment failed");
}
H5std_string comment = H5std_string( comment_C );
H5std_string comment = H5std_string(comment_C);
delete []comment_C;
return (comment);
}
@ -532,7 +532,7 @@ H5std_string CommonFG::getComment( const char* name, size_t bufsize ) const
{
throwException("getComment", "H5Gget_comment failed");
}
H5std_string comment = H5std_string( comment_C );
H5std_string comment = H5std_string(comment_C);
delete []comment_C;
return( comment );
}
@ -1017,8 +1017,8 @@ ssize_t CommonFG::getObjnameByIdx(hsize_t idx, H5std_string& name, size_t size)
{
throwException("getObjnameByIdx", "H5Gget_objname_by_idx failed");
}
name = H5std_string( name_C );
delete [] name_C;
name = H5std_string(name_C);
delete []name_C;
return (name_len);
}

2
c++/src/H5CommonFG.h
View File

@ -151,7 +151,7 @@ class H5_DLLCPP CommonFG {
#endif // DOXYGEN_SHOULD_SKIP_THIS
/// For subclasses, H5File and Group, to throw appropriate exception.
virtual void throwException(const H5std_string func_name, const H5std_string msg) const = 0;
virtual void throwException(const H5std_string& func_name, const H5std_string& msg) const = 0;
// Default constructor.
CommonFG();

42
c++/src/H5CompType.cpp
View File

@ -191,7 +191,7 @@ H5T_class_t CompType::getMemberClass( unsigned member_num ) const
if( member_class == H5T_NO_CLASS )
{
throw DataTypeIException("CompType::getMemberClass",
"H5Tget_member_class returns H5T_NO_CLASS");
"H5Tget_member_class returns H5T_NO_CLASS");
}
return(member_class);
}
@ -254,26 +254,6 @@ ArrayType CompType::getMemberArrayType( unsigned member_num ) const
}
}
//--------------------------------------------------------------------------
// Function: CompType::getMemberEnumType
///\brief Returns the enumeration datatype of the specified member in
/// this compound datatype.
///\param member_num - IN: Zero-based index of the member
///\return EnumType instance
///\exception H5::DataTypeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
EnumType CompType::getMemberEnumType( unsigned member_num ) const
{
try {
EnumType enumtype(p_get_member_type(member_num));
return(enumtype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberEnumType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: CompType::getMemberCompType
///\brief Returns the compound datatype of the specified member in this
@ -294,6 +274,26 @@ CompType CompType::getMemberCompType( unsigned member_num ) const
}
}
//--------------------------------------------------------------------------
// Function: CompType::getMemberEnumType
///\brief Returns the enumeration datatype of the specified member in
/// this compound datatype.
///\param member_num - IN: Zero-based index of the member
///\return EnumType instance
///\exception H5::DataTypeIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
EnumType CompType::getMemberEnumType( unsigned member_num ) const
{
try {
EnumType enumtype(p_get_member_type(member_num));
return(enumtype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberEnumType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: CompType::getMemberIntType
///\brief Returns the integer datatype of the specified member in this

20
c++/src/H5DataSet.cpp
View File

@ -46,7 +46,7 @@ namespace H5 {
///\brief Default constructor: creates a stub DataSet.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
DataSet::DataSet() : AbstractDs() {}
DataSet::DataSet() : AbstractDs() {}
//--------------------------------------------------------------------------
// Function: DataSet overloaded constructor
@ -436,7 +436,7 @@ void* DataSet::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_
///\brief This is an overloaded function, provided for your convenience.
/// It differs from the above function in that it only creates
/// a reference to an HDF5 object, not to a dataset region.
///\param name - IN: Name of the object to be referenced
///\param name - IN: Name of the object to be referenced - \c char pointer
///\return A reference
///\exception H5::DataSetIException
///\par Description
@ -474,10 +474,10 @@ void* DataSet::Reference(const H5std_string& name) const
///\param ref_type - IN: Type of reference to query
///\param ref - IN: Reference to query
///\return An object type, which can be one of the following:
// H5G_LINK Object is a symbolic link.
// H5G_GROUP Object is a group.
// H5G_DATASET Object is a dataset.
// H5G_TYPE Object is a named datatype
/// \li \c H5G_LINK Object is a symbolic link.
/// \li \c H5G_GROUP Object is a group.
/// \li \c H5G_DATASET Object is a dataset.
/// \li \c H5G_TYPE Object is a named datatype
///\exception H5::DataSetIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
@ -526,7 +526,7 @@ void DataSet::close()
herr_t ret_value = H5Dclose( id );
if( ret_value < 0 )
{
throw DataSetIException("DataSet::close", "H5Dclose failed");
throw DataSetIException("DataSet::close", "H5Dclose failed");
}
// reset the id because the dataset that it represents is now closed
id = 0;
@ -538,8 +538,10 @@ void DataSet::close()
///\brief Properly terminates access to this dataset.
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
DataSet::~DataSet()
{

22
c++/src/H5DataSpace.cpp
View File

@ -98,8 +98,10 @@ DataSpace::DataSpace( const DataSpace& original ) : IdComponent( original ) {}
///\exception H5::DataSpaceIException
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
void DataSpace::copy( const DataSpace& like_space )
{
@ -410,7 +412,7 @@ void DataSpace::getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints,
if( ret_value < 0 )
{
throw DataSpaceIException("DataSpace::getSelectElemPointlist",
"H5Sget_select_elem_pointlist failed");
"H5Sget_select_elem_pointlist failed");
}
}
@ -433,7 +435,7 @@ void DataSpace::getSelectBounds ( hsize_t* start, hsize_t* end ) const
if( ret_value < 0 )
{
throw DataSpaceIException("DataSpace::getSelectBounds",
"H5Sget_select_bounds failed");
"H5Sget_select_bounds failed");
}
}
@ -460,7 +462,7 @@ void DataSpace::selectElements ( H5S_seloper_t op, const size_t num_elements, co
if( ret_value < 0 )
{
throw DataSpaceIException("DataSpace::selectElements",
"H5Sselect_elements failed");
"H5Sselect_elements failed");
}
}
@ -493,7 +495,7 @@ void DataSpace::selectNone () const
if( ret_value < 0 )
{
throw DataSpaceIException("DataSpace::selectNone",
"H5Sselect_none failed");
"H5Sselect_none failed");
}
}
@ -516,7 +518,7 @@ bool DataSpace::selectValid () const
else
{
throw DataSpaceIException("DataSpace::selectValid",
"H5Sselect_valid returns negative value");
"H5Sselect_valid returns negative value");
}
}
@ -573,8 +575,10 @@ void DataSpace::close()
///\brief Properly terminates access to this dataspace.
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
DataSpace::~DataSpace()
{

4
c++/src/H5DataSpace.h
View File

@ -34,8 +34,8 @@ class H5_DLLCPP DataSpace : public IdComponent {
// Assignment operator
DataSpace& operator=( const DataSpace& rhs );
// Closes this dataspace.
virtual void close();
// Closes this dataspace.
virtual void close();
// Makes copy of an existing dataspace.
void copy(const DataSpace& like_space);

49
c++/src/H5DataType.cpp
View File

@ -96,18 +96,19 @@ DataType::DataType(const DataType& original) : H5Object(original) {}
///\exception H5::DataTypeIException
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
void DataType::copy( const DataType& like_type )
{
// If this object is representing an hdf5 object, close it before
// copying like_type to it
// close the current data type before copying like_type to this object
try {
close();
close();
}
catch (Exception close_error) {
throw FileIException("DataType::copy", close_error.getDetailMsg());
throw DataTypeIException("DataType::copy", close_error.getDetailMsg());
}
// call C routine to copy the datatype
@ -131,8 +132,8 @@ DataType& DataType::operator=( const DataType& rhs )
{
if (this != &rhs)
{
copy(rhs);
return(*this);
copy(rhs);
return(*this);
}
}
@ -468,20 +469,20 @@ void DataType::setTag( const H5std_string& tag ) const
//--------------------------------------------------------------------------
H5std_string DataType::getTag() const
{
char* tag_Cstr = H5Tget_tag( id );
char* tag_Cstr = H5Tget_tag( id );
// if the tag C-string returned is not NULL, convert it to C++ string
// and return it, otherwise, raise an exception
if( tag_Cstr != NULL )
{
H5std_string tag = H5std_string(tag_Cstr); // convert C string to string object
// if the tag C-string returned is not NULL, convert it to C++ string
// and return it, otherwise, raise an exception
if( tag_Cstr != NULL )
{
H5std_string tag = H5std_string(tag_Cstr); // C string to string object
HDfree(tag_Cstr); // free the C string
return (tag); // return the tag
}
else
{
throw DataTypeIException(inMemFunc("getTag"), "H5Tget_tag returns NULL for tag");
}
return (tag); // return the tag
}
else
{
throw DataTypeIException(inMemFunc("getTag"), "H5Tget_tag returns NULL for tag");
}
}
//--------------------------------------------------------------------------
@ -643,7 +644,7 @@ void DataType::close()
herr_t ret_value = H5Tclose(id);
if( ret_value < 0 )
{
throw DataTypeIException(inMemFunc("close"), "H5Tclose failed");
throw DataTypeIException(inMemFunc("close"), "H5Tclose failed");
}
// reset the id because the datatype that it represents is now closed
id = 0;
@ -655,8 +656,10 @@ void DataType::close()
///\brief Properly terminates access to this datatype.
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
DataType::~DataType()
{

1
c++/src/H5DataType.h
View File

@ -104,6 +104,7 @@ class H5_DLLCPP DataType : public H5Object {
// Retrieves a dataspace with the region pointed to selected.
DataSpace getRegion(void *ref, H5R_type_t ref_type = H5R_DATASET_REGION) const;
// Returns this class name
virtual H5std_string fromClass () const { return("DataType"); }
// Creates a copy of an existing DataType using its id

18
c++/src/H5DcreatProp.cpp
View File

@ -262,7 +262,8 @@ H5D_fill_value_t DSetCreatPropList::isFillValueDefined()
/// and the filter fails then the entire I/O operation fails.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetCreatPropList::setFilter( H5Z_filter_t filter_id, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const
void DSetCreatPropList::setFilter( H5Z_filter_t filter_id, unsigned int flags,
size_t cd_nelmts, const unsigned int cd_values[] ) const
{
herr_t ret_value = H5Pset_filter( id, filter_id, flags, cd_nelmts, cd_values );
if( ret_value < 0 )
@ -328,9 +329,9 @@ int DSetCreatPropList::getNfilters() const
///\par Description
/// Failure occurs when \a filter_number is out of range.
//--------------------------------------------------------------------------
H5Z_filter_t DSetCreatPropList::getFilter(int filter_number, unsigned int &flags, size_t &cd_nelmts,
unsigned int* cd_values, size_t namelen, char name[],
unsigned int& filter_config) const
H5Z_filter_t DSetCreatPropList::getFilter(int filter_number,
unsigned int &flags, size_t &cd_nelmts, unsigned int* cd_values,
size_t namelen, char name[], unsigned int& filter_config) const
{
H5Z_filter_t filter_id;
filter_id = H5Pget_filter( id, filter_number, &flags, &cd_nelmts,
@ -359,9 +360,9 @@ H5Z_filter_t DSetCreatPropList::getFilter(int filter_number, unsigned int &flags
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetCreatPropList::getFilterById(H5Z_filter_t filter_id, unsigned int &flags, size_t &cd_nelmts,
unsigned int* cd_values, size_t namelen, char name[],
unsigned int &filter_config) const
void DSetCreatPropList::getFilterById(H5Z_filter_t filter_id,
unsigned int &flags, size_t &cd_nelmts, unsigned int* cd_values,
size_t namelen, char name[], unsigned int &filter_config) const
{
herr_t ret_value = H5Pget_filter_by_id(id, filter_id, &flags, &cd_nelmts,
cd_values, namelen, name, &filter_config );
@ -393,7 +394,8 @@ void DSetCreatPropList::getFilterById(H5Z_filter_t filter_id, unsigned int &flag
/// and the filter fails then the entire I/O operation fails.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetCreatPropList::modifyFilter( H5Z_filter_t filter_id, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const
void DSetCreatPropList::modifyFilter( H5Z_filter_t filter_id, unsigned int
flags, size_t cd_nelmts, const unsigned int cd_values[] ) const
{
herr_t ret_value = H5Pmodify_filter(id, filter_id, flags, cd_nelmts, cd_values);
if( ret_value < 0 )

6
c++/src/H5DcreatProp.h
View File

@ -25,6 +25,9 @@ class H5_DLLCPP DSetCreatPropList : public PropList {
// Default dataset creation property list.
static const DSetCreatPropList DEFAULT;
// Creates a dataset creation property list.
DSetCreatPropList();
// Queries whether all the filters set in this property list are
// available currently.
bool allFiltersAvail();
@ -103,9 +106,6 @@ class H5_DLLCPP DSetCreatPropList : public PropList {
// Returns this class name
virtual H5std_string fromClass () const { return("DSetCreatPropList"); }
// Default constructor: creates a stub dataset creation property list.
DSetCreatPropList();
// Copy constructor: creates a copy of a DSetCreatPropList object.
DSetCreatPropList(const DSetCreatPropList& orig);

12
c++/src/H5DxferProp.cpp
View File

@ -41,11 +41,11 @@ DSetMemXferPropList::DSetMemXferPropList() : PropList(H5P_DATASET_XFER) {}
// Function DSetMemXferPropList copy constructor
///\brief Copy constructor: makes a copy of the original
/// DSetMemXferPropList object
///\param orig - IN: The original dataset memory and transfer property
///\param original - IN: Original dataset memory and transfer property
/// list object to copy
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
DSetMemXferPropList::DSetMemXferPropList( const DSetMemXferPropList& orig ) : PropList( orig ) {}
DSetMemXferPropList::DSetMemXferPropList(const DSetMemXferPropList& original ) : PropList( original ) {}
//--------------------------------------------------------------------------
// Function DSetMemXferPropList overloaded constructor
@ -188,7 +188,7 @@ void DSetMemXferPropList::setTypeConvCB( H5T_conv_except_func_t op, void *user_d
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::setTypeConvCB",
"H5Pset_type_conv_cb failed");
"H5Pset_type_conv_cb failed");
}
}
@ -206,7 +206,7 @@ void DSetMemXferPropList::getTypeConvCB( H5T_conv_except_func_t *op, void **user
if( ret_value < 0 )
{
throw PropListIException("DSetMemXferPropList::getTypeConvCB",
"H5Pget_type_conv_cb failed");
"H5Pget_type_conv_cb failed");
}
}
@ -325,7 +325,7 @@ void DSetMemXferPropList::setSmallDataBlockSize(hsize_t size)
// Function: DSetMemXferPropList::getSmallDataBlockSize
///\brief Returns the current small data block size setting.
///\return Size of the small data block, in bytes
///\exception H5::PropListIException
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
hsize_t DSetMemXferPropList::getSmallDataBlockSize()
@ -362,7 +362,7 @@ void DSetMemXferPropList::setHyperVectorSize(size_t vector_size)
}
//--------------------------------------------------------------------------
// Function: DSetMemXferPropList::getSmallDataBlockSize
// Function: DSetMemXferPropList::getHyperVectorSize
///\brief Returns the number of I/O vectors to be read/written in
/// hyperslab I/O.
///\return Number of I/O vectors

42
c++/src/H5DxferProp.h
View File

@ -24,47 +24,44 @@ class H5_DLLCPP DSetMemXferPropList : public PropList {
public:
static const DSetMemXferPropList DEFAULT;
// Creates a dataset memory and transfer property list
// Creates a dataset memory and transfer property list.
DSetMemXferPropList();
// Copy constructor: creates a copy of a DSetMemXferPropList object
DSetMemXferPropList( const DSetMemXferPropList& orig );
// Sets type conversion and background buffers
// Sets type conversion and background buffers.
void setBuffer( size_t size, void* tconv, void* bkg ) const;
// Reads buffer settings
// Reads buffer settings.
size_t getBuffer( void** tconv, void** bkg ) const;
// Sets the dataset transfer property list status to TRUE or FALSE
void setPreserve( bool status ) const;
// Checks status of the dataset transfer property list
bool getPreserve() const;
// Sets B-tree split ratios for a dataset transfer property list
// Sets B-tree split ratios for a dataset transfer property list.
void setBtreeRatios( double left, double middle, double right ) const;
// Gets B-tree split ratios for a dataset transfer property list
// Gets B-tree split ratios for a dataset transfer property list.
void getBtreeRatios( double& left, double& middle, double& right ) const;
// Sets an exception handling callback for datatype conversion
// Sets the dataset transfer property list status to TRUE or FALSE.
void setPreserve( bool status ) const;
// Checks status of the dataset transfer property list.
bool getPreserve() const;
// Sets an exception handling callback for datatype conversion.
void setTypeConvCB( H5T_conv_except_func_t op, void *user_data) const;
// Gets the exception handling callback for datatype conversion
// Gets the exception handling callback for datatype conversion.
void getTypeConvCB( H5T_conv_except_func_t *op, void **user_data) const;
// Sets the memory manager for variable-length datatype
// allocation in H5Dread and H5Dvlen_reclaim
// allocation in H5Dread and H5Dvlen_reclaim.
void setVlenMemManager( H5MM_allocate_t alloc, void* alloc_info,
H5MM_free_t free, void* free_info ) const;
// alloc and free are set to NULL, indicating that system
// malloc and free are to be used
// malloc and free are to be used.
void setVlenMemManager() const;
// Gets the memory manager for variable-length datatype
// allocation in H5Dread and H5Tvlen_reclaim
// allocation in H5Dread and H5Tvlen_reclaim.
void getVlenMemManager( H5MM_allocate_t& alloc, void** alloc_info,
H5MM_free_t& free, void** free_info ) const;
@ -94,12 +91,15 @@ class H5_DLLCPP DSetMemXferPropList : public PropList {
// Determines whether error-detection is enabled for dataset reads.
H5Z_EDC_t getEDCCheck();
// Returns this class name
// Returns this class name.
virtual H5std_string fromClass () const { return("DSetMemXferPropList"); }
// Copy constructor: makes a copy of a DSetMemXferPropList object.
DSetMemXferPropList(const DSetMemXferPropList& orig);
// Creates a copy of an existing dataset memory and transfer
// property list using the property list id.
DSetMemXferPropList (const hid_t plist_id);
DSetMemXferPropList(const hid_t plist_id);
// Noop destructor
virtual ~DSetMemXferPropList();

4
c++/src/H5EnumType.cpp
View File

@ -159,8 +159,8 @@ H5std_string EnumType::nameOf( void *value, size_t size ) const
throw DataTypeIException("EnumType::nameOf", "H5Tenum_nameof failed");
}
// otherwise, create the string to hold the datatype name and return it
H5std_string name = H5std_string( name_C );
delete [] name_C;
H5std_string name = H5std_string(name_C);
delete []name_C;
return( name );
}

22
c++/src/H5Exception.cpp
View File

@ -38,7 +38,7 @@ Exception::Exception() : detail_message(""), func_name("") {}
///\param message - IN: Message on the failure
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Exception::Exception(const H5std_string func_name, const H5std_string message) : detail_message(message), func_name(func_name) {}
Exception::Exception(const H5std_string& func_name, const H5std_string& message) : detail_message(message), func_name(func_name) {}
//--------------------------------------------------------------------------
// Function: Exception copy constructor
@ -329,7 +329,7 @@ FileIException::FileIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
FileIException::FileIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
FileIException::FileIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: FileIException destructor
///\brief Noop destructor.
@ -352,7 +352,7 @@ GroupIException::GroupIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
GroupIException::GroupIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
GroupIException::GroupIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: GroupIException destructor
///\brief Noop destructor.
@ -375,7 +375,7 @@ DataSpaceIException::DataSpaceIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
DataSpaceIException::DataSpaceIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
DataSpaceIException::DataSpaceIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: DataSpaceIException destructor
///\brief Noop destructor.
@ -398,7 +398,7 @@ DataTypeIException::DataTypeIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
DataTypeIException::DataTypeIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
DataTypeIException::DataTypeIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: DataTypeIException destructor
///\brief Noop destructor.
@ -421,7 +421,7 @@ PropListIException::PropListIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
PropListIException::PropListIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
PropListIException::PropListIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: PropListIException destructor
///\brief Noop destructor.
@ -444,7 +444,7 @@ DataSetIException::DataSetIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
DataSetIException::DataSetIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
DataSetIException::DataSetIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: DataSetIException destructor
///\brief Noop destructor.
@ -467,7 +467,7 @@ AttributeIException::AttributeIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
AttributeIException::AttributeIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
AttributeIException::AttributeIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: AttributeIException destructor
///\brief Noop destructor.
@ -490,7 +490,7 @@ ReferenceException::ReferenceException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
ReferenceException::ReferenceException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
ReferenceException::ReferenceException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: ReferenceException destructor
///\brief Noop destructor.
@ -513,7 +513,7 @@ LibraryIException::LibraryIException():Exception(){}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
LibraryIException::LibraryIException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
LibraryIException::LibraryIException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: LibraryIException destructor
///\brief Noop destructor.
@ -536,7 +536,7 @@ IdComponentException::IdComponentException(): Exception() {}
///\param func_name - IN: Name of the function where failure occurs
///\param message - IN: Message on the failure
//--------------------------------------------------------------------------
IdComponentException::IdComponentException(const H5std_string func_name, const H5std_string message) : Exception(func_name, message) {}
IdComponentException::IdComponentException(const H5std_string& func_name, const H5std_string& message) : Exception(func_name, message) {}
//--------------------------------------------------------------------------
// Function: IdComponentException destructor
///\brief Noop destructor.

22
c++/src/H5Exception.h
View File

@ -31,7 +31,7 @@ class H5_DLLCPP Exception {
public:
// Creates an exception with a function name where the failure occurs
// and an optional detailed message
Exception(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
Exception(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
// Returns a character string that describes the error specified by
// a major error number.
@ -94,70 +94,70 @@ class H5_DLLCPP Exception {
class H5_DLLCPP FileIException : public Exception {
public:
FileIException( const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
FileIException( const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
FileIException();
virtual ~FileIException();
};
class H5_DLLCPP GroupIException : public Exception {
public:
GroupIException( const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
GroupIException( const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
GroupIException();
virtual ~GroupIException();
};
class H5_DLLCPP DataSpaceIException : public Exception {
public:
DataSpaceIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
DataSpaceIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
DataSpaceIException();
virtual ~DataSpaceIException();
};
class H5_DLLCPP DataTypeIException : public Exception {
public:
DataTypeIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
DataTypeIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
DataTypeIException();
virtual ~DataTypeIException();
};
class H5_DLLCPP PropListIException : public Exception {
public:
PropListIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
PropListIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
PropListIException();
virtual ~PropListIException();
};
class H5_DLLCPP DataSetIException : public Exception {
public:
DataSetIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
DataSetIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
DataSetIException();
virtual ~DataSetIException();
};
class H5_DLLCPP AttributeIException : public Exception {
public:
AttributeIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
AttributeIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
AttributeIException();
virtual ~AttributeIException();
};
class H5_DLLCPP ReferenceException : public Exception {
public:
ReferenceException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
ReferenceException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
ReferenceException();
virtual ~ReferenceException();
};
class H5_DLLCPP LibraryIException : public Exception {
public:
LibraryIException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
LibraryIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
LibraryIException();
virtual ~LibraryIException();
};
class H5_DLLCPP IdComponentException : public Exception {
public:
IdComponentException(const H5std_string func_name, const H5std_string message = DEFAULT_MSG);
IdComponentException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
IdComponentException();
virtual ~IdComponentException();
};

28
c++/src/H5FaccProp.cpp
View File

@ -31,23 +31,23 @@ const FileAccPropList FileAccPropList::DEFAULT;
//--------------------------------------------------------------------------
// Function: Default Constructor
///\brief Default constructor: creates a file access property list
///\brief Creates a file access property list
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
FileAccPropList::FileAccPropList() : PropList( H5P_FILE_ACCESS ) {}
//--------------------------------------------------------------------------
// Function: FileAccPropList copy constructor
///\brief Copy Constructor: makes a copy of the original
/// FileAccPropList object.
///\brief Copy Constructor: makes a copy of the original
/// FileAccPropList object.
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
FileAccPropList::FileAccPropList(const FileAccPropList& orig) : PropList(orig) {}
//--------------------------------------------------------------------------
// Function: FileAccPropList overloaded constructor
///\brief Creates a file access property list using the id of an
/// existing one.
///\brief Creates a file access property list using the id of an
/// existing one.
// Programmer: Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
FileAccPropList::FileAccPropList(const hid_t plist_id) : PropList(plist_id) {}
@ -70,7 +70,7 @@ void FileAccPropList::setStdio() const
//--------------------------------------------------------------------------
// Function: FileAccPropList::getDriver
///\brief Return the ID of the low-level file driver.
///\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.
@ -229,9 +229,9 @@ void FileAccPropList::getFamily(hsize_t& memb_size, FileAccPropList& memb_plist)
//--------------------------------------------------------------------------
// Function: FileAccPropList::getFamily
///\brief This is an overloaded member function, provided for convenience.
/// It differs from the above function only in what arguments it
/// accepts and its return value.
///\brief This is an overloaded member function, provided for convenience.
/// It differs from the above function only in what arguments it
/// accepts and its return value.
///\param memb_size - OUT: Size in bytes of each file member
///\return The file access property list for each file member
///\exception H5::PropListIException
@ -276,9 +276,9 @@ void FileAccPropList::setSplit( FileAccPropList& meta_plist, FileAccPropList& ra
//--------------------------------------------------------------------------
// Function: FileAccPropList::setSplit
///\brief This is an overloaded member function, provided for convenience.
/// It differs from the above function only in what arguments it
/// accepts.
///\brief This is an overloaded member function, provided for convenience.
/// It differs from the above function only in what arguments it
/// accepts.
///\param meta_plist - IN: File access plist for the metadata file
///\param raw_plist - IN: File access plist for the raw data file
///\param meta_ext - IN: Metadata filename extension as \c string
@ -666,9 +666,9 @@ unsigned FileAccPropList::getGcReferences() const
}
//--------------------------------------------------------------------------
// Function: FileAccPropList destructor
// Function: FileAccPropList destructor
///\brief Noop destructor
// Programmer Binh-Minh Ribler - 2000
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
FileAccPropList::~FileAccPropList() {}

6
c++/src/H5FaccProp.h
View File

@ -25,6 +25,9 @@ class H5_DLLCPP FileAccPropList : public PropList {
public:
static const FileAccPropList DEFAULT;
// Creates a file access property list.
FileAccPropList();
// Modifies this property list to use the H5FD_STDIO driver
void setStdio() const;
@ -122,9 +125,6 @@ class H5_DLLCPP FileAccPropList : public PropList {
// Returns this class name
virtual H5std_string fromClass () const { return("FileAccPropList"); }
// Creates a file access property list.
FileAccPropList();
// Copy constructor: creates a copy of a FileAccPropList object.
FileAccPropList( const FileAccPropList& original );

6
c++/src/H5FcreatProp.h
View File

@ -26,6 +26,9 @@ class H5_DLLCPP FileCreatPropList : public PropList {
// Default file creation property list.
static const FileCreatPropList DEFAULT;
// Creates a file create property list.
FileCreatPropList();
// Retrieves version information for various parts of a file.
void getVersion( unsigned& super, unsigned& freelist, unsigned& stab, unsigned& shhdr ) const;
@ -59,9 +62,6 @@ class H5_DLLCPP FileCreatPropList : public PropList {
// Returns this class name
virtual H5std_string fromClass () const { return("FileCreatPropList"); }
// Creates a file create property list.
FileCreatPropList();
// Copy constructor: creates a copy of a FileCreatPropList object.
FileCreatPropList(const FileCreatPropList& orig);

18
c++/src/H5File.cpp
View File

@ -251,12 +251,10 @@ void H5File::openFile(const H5std_string& name, unsigned int flags, const FileAc
// be investigated. BMR - 2/20/2005
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// ID reference counting mechanism - BMR, Jun 1, 2004
//--------------------------------------------------------------------------
void H5File::reOpen()
{
// If this object has a valid id, appropriately decrement reference
// counter and close the id.
try {
close();
}
@ -488,7 +486,7 @@ void H5File::getVFDHandle(void **file_handle) const
// Function: H5File::getFileName
///\brief Gets the name of this file.
///\return File name
///\exception H5::IdComponentException
///\exception H5::FileIException
// Programmer Binh-Minh Ribler - Jul, 2004
//--------------------------------------------------------------------------
H5std_string H5File::getFileName() const
@ -508,7 +506,7 @@ H5std_string H5File::getFileName() const
///\param dataspace - IN: Dataspace with selection
///\param ref_type - IN: Type of reference; default to \c H5R_DATASET_REGION
///\return A reference
///\exception H5::IdComponentException
///\exception H5::FileIException
///\par Description
/// Note that name must be an absolute path to the object in the file.
// Programmer Binh-Minh Ribler - May, 2004
@ -530,7 +528,7 @@ void* H5File::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_t
/// a reference to an HDF5 object, not to a dataset region.
///\param name - IN: Name of the object to be referenced
///\return A reference
///\exception H5::IdComponentException
///\exception H5::FileIException
///\par Description
// This function passes H5R_OBJECT and -1 to the protected
// function for it to pass to the C API H5Rcreate
@ -573,7 +571,7 @@ void* H5File::Reference(const H5std_string& name) const
/// \li \c H5G_GROUP - Object is a group.
/// \li \c H5G_DATASET - Object is a dataset.
/// \li \c H5G_TYPE - Object is a named datatype
///\exception H5::IdComponentException
///\exception H5::FileIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
H5G_obj_t H5File::getObjType(void *ref, H5R_type_t ref_type) const
@ -592,7 +590,7 @@ H5G_obj_t H5File::getObjType(void *ref, H5R_type_t ref_type) const
///\param ref - IN: Reference to get region of
///\param ref_type - IN: Type of reference to get region of - default
///\return DataSpace instance
///\exception H5::IdComponentException
///\exception H5::FileIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
DataSpace H5File::getRegion(void *ref, H5R_type_t ref_type) const
@ -675,7 +673,7 @@ void H5File::close()
// implementation of H5File.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void H5File::throwException(const H5std_string func_name, const H5std_string msg) const
void H5File::throwException(const H5std_string& func_name, const H5std_string& msg) const
{
H5std_string full_name = func_name;
full_name.insert(0, "H5File::");
@ -688,7 +686,7 @@ void H5File::throwException(const H5std_string func_name, const H5std_string msg
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// ID reference counting mechanism - BMR, Jun 1, 2004
//--------------------------------------------------------------------------
H5File::~H5File()
{

10
c++/src/H5File.h
View File

@ -36,8 +36,8 @@ class H5_DLLCPP H5File : public IdComponent, public CommonFG {
void openFile(const char* name, unsigned int flags,
const FileAccPropList& access_plist = FileAccPropList::DEFAULT);
// Close this file.
virtual void close();
// Close this file.
virtual void close();
// Flushes all buffers associated with this file to disk
void flush(H5F_scope_t scope) const;
@ -51,8 +51,8 @@ class H5_DLLCPP H5File : public IdComponent, public CommonFG {
// Gets the name of this file.
H5std_string getFileName() const;
// Retrieves the file size of an opened file.
hsize_t getFileSize() const;
// Retrieves the file size of an opened file.
hsize_t getFileSize() const;
// Returns the amount of free space in the file.
hssize_t getFreeSpace() const;
@ -96,7 +96,7 @@ class H5_DLLCPP H5File : public IdComponent, public CommonFG {
virtual H5std_string fromClass () const { return("H5File"); }
// Throw file exception.
virtual void throwException(const H5std_string func_name, const H5std_string msg) const;
virtual void throwException(const H5std_string& func_name, const H5std_string& msg) const;
// Gets the file id
virtual hid_t getLocId() const;

14
c++/src/H5Group.cpp
View File

@ -128,7 +128,7 @@ void* Group::Reference(const char* name) const
/// It differs from the above function in that it takes an
/// \c std::string for the object's name.
///\param name - IN: Name of the object to be referenced
// Programmer Binh-Minh Ribler - May, 2004
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* Group::Reference(const H5std_string& name) const
{
@ -141,10 +141,10 @@ void* Group::Reference(const H5std_string& name) const
///\param ref - IN: Reference to query
///\param ref_type - IN: Type of reference to query
///\return An object type, which can be one of the following:
// H5G_LINK Object is a symbolic link.
// H5G_GROUP Object is a group.
// H5G_DATASET Object is a dataset.
// H5G_TYPE Object is a named datatype
/// H5G_LINK Object is a symbolic link.
/// H5G_GROUP Object is a group.
/// H5G_DATASET Object is a dataset.
/// H5G_TYPE Object is a named datatype
///\exception H5::GroupIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
@ -213,7 +213,7 @@ void Group::close()
// implementation of Group.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void Group::throwException(const H5std_string func_name, const H5std_string msg) const
void Group::throwException(const H5std_string& func_name, const H5std_string& msg) const
{
H5std_string full_name = func_name;
full_name.insert(0, "Group::");
@ -226,7 +226,7 @@ void Group::throwException(const H5std_string func_name, const H5std_string msg)
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// ID reference counting mechanism - BMR, Jun 1, 2004
//--------------------------------------------------------------------------
Group::~Group()
{

12
c++/src/H5Group.h
View File

@ -22,8 +22,8 @@ namespace H5 {
class H5_DLLCPP Group : public H5Object, public CommonFG {
public:
// Close this group.
virtual void close();
// Close this group.
virtual void close();
// Retrieves the type of object that an object reference points to.
H5G_obj_t getObjType(void *ref, H5R_type_t ref_type) const;
@ -42,8 +42,8 @@ class H5_DLLCPP Group : public H5Object, public CommonFG {
// Returns this class name
virtual H5std_string fromClass () const { return("Group"); }
// Throw group exception.
virtual void throwException(const H5std_string func_name, const H5std_string msg) const;
// Throw group exception.
virtual void throwException(const H5std_string& func_name, const H5std_string& msg) const;
// for CommonFG to get the file id.
virtual hid_t getLocId() const;
@ -57,8 +57,8 @@ class H5_DLLCPP Group : public H5Object, public CommonFG {
// Destructor
virtual ~Group();
// Creates a copy of an existing group using its id.
Group( const hid_t group_id );
// Creates a copy of an existing group using its id.
Group( const hid_t group_id );
};
#ifndef H5_NO_NAMESPACE

37
c++/src/H5IdComponent.cpp
View File

@ -56,7 +56,7 @@ void IdComponent::incRefCount(const hid_t obj_id) const
{
if (p_valid_id(obj_id))
if (H5Iinc_ref(obj_id) < 0)
throw IdComponentException(inMemFunc("incRefCount"), "incrementing object ref count failed");
throw IdComponentException(inMemFunc("incRefCount"), "incrementing object ref count failed");
}
//--------------------------------------------------------------------------
@ -80,15 +80,13 @@ void IdComponent::incRefCount() const
void IdComponent::decRefCount(const hid_t obj_id) const
{
if (p_valid_id(obj_id))
{
if (H5Idec_ref(obj_id) < 0)
if (H5Idec_ref(obj_id) < 0)
if (H5Iget_ref(obj_id) <= 0)
throw IdComponentException(inMemFunc("decRefCount"),
"object ref count is 0 or negative");
else
throw IdComponentException(inMemFunc("decRefCount"),
"decrementing object ref count failed");
}
}
//--------------------------------------------------------------------------
@ -114,7 +112,7 @@ int IdComponent::getCounter(const hid_t obj_id) const
{
counter = H5Iget_ref(obj_id);
if (counter < 0)
throw IdComponentException(inMemFunc("incRefCount"), "getting object ref count failed - negative");
throw IdComponentException(inMemFunc("incRefCount"), "getting object ref count failed - negative");
}
return (counter);
}
@ -131,9 +129,9 @@ int IdComponent::getCounter() const
}
//--------------------------------------------------------------------------
// Function: hdfObjectType
///\brief Given an id, returns the type of the object.
///return a valid HDF object type, which may be one of the following:
// Function: hdfObjectType
///\brief Given an id, returns the type of the object.
///return a valid HDF object type, which may be one of the following:
/// \li \c H5I_FILE
/// \li \c H5I_GROUP
/// \li \c H5I_DATATYPE
@ -148,9 +146,9 @@ H5I_type_t IdComponent::getHDFObjType(const hid_t obj_id)
{
H5I_type_t id_type = H5Iget_type(obj_id);
if (id_type <= H5I_BADID || id_type >= H5I_NTYPES)
return H5I_BADID; // invalid
return H5I_BADID; // invalid
else
return id_type; // valid type
return id_type; // valid type
}
//--------------------------------------------------------------------------
@ -161,11 +159,10 @@ H5I_type_t IdComponent::getHDFObjType(const hid_t obj_id)
///\exception H5::IdComponentException when attempt to close the HDF5
/// object fails
// Description
// The underlaying reference counting in the C library ensures
// that the current valid id of this object is properly closed.
// Copy the id from rhs to this object, then increment the
// First, close the current valid id of this object. Then
// copy the id from rhs to this object, and increment the
// reference counter of the id to indicate that another object
// is referencing it.
// is referencing that id.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
IdComponent& IdComponent::operator=( const IdComponent& rhs )
@ -174,10 +171,10 @@ IdComponent& IdComponent::operator=( const IdComponent& rhs )
{
// handling references to this id
try {
close();
close();
}
catch (Exception close_error) {
throw FileIException(inMemFunc("operator="), close_error.getDetailMsg());
throw FileIException(inMemFunc("operator="), close_error.getDetailMsg());
}
// copy the data members from the rhs object
@ -205,10 +202,10 @@ void IdComponent::setId(const hid_t new_id)
{
// handling references to this old id
try {
close();
close();
}
catch (Exception close_error) {
throw IdComponentException(inMemFunc("copy"), close_error.getDetailMsg());
throw IdComponentException(inMemFunc("copy"), close_error.getDetailMsg());
}
// reset object's id to the given id
@ -237,8 +234,10 @@ hid_t IdComponent::getId () const
IdComponent::~IdComponent() {}
//
// Implementation of protected functions for HDF5 Reference Interface.
// Implementation of protected functions for HDF5 Reference Interface
// and miscelaneous helpers.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//--------------------------------------------------------------------------
// Function: IdComponent::inMemFunc

20
c++/src/H5IdComponent.h
View File

@ -39,7 +39,7 @@ class H5_DLLCPP IdComponent {
// Returns an HDF object type, given the object id.
static H5I_type_t getHDFObjType(const hid_t obj_id);
// Assignment operator.
// Assignment operator
IdComponent& operator=( const IdComponent& rhs );
// Sets the identifier of this object to a new value.
@ -64,7 +64,7 @@ class H5_DLLCPP IdComponent {
H5std_string inMemFunc(const char* func_name) const;
// Returns this class name.
virtual H5std_string fromClass() const { return("IdComponent");}
virtual H5std_string fromClass() const { return("IdComponent");}
#endif // DOXYGEN_SHOULD_SKIP_THIS
@ -81,17 +81,17 @@ class H5_DLLCPP IdComponent {
// Gets the name of the file, in which an HDF5 object belongs.
H5std_string p_get_file_name() const;
// Gets the id of the H5 file in which the given object is located.
hid_t p_get_file_id();
// Gets the id of the H5 file in which the given object is located.
hid_t p_get_file_id();
// Creates a reference to an HDF5 object or a dataset region.
void* p_reference(const char* name, hid_t space_id, H5R_type_t ref_type) const;
// Creates a reference to an HDF5 object or a dataset region.
void* p_reference(const char* name, hid_t space_id, H5R_type_t ref_type) const;
// Retrieves the type of object that an object reference points to.
H5G_obj_t p_get_obj_type(void *ref, H5R_type_t ref_type) const;
// Retrieves the type of object that an object reference points to.
H5G_obj_t p_get_obj_type(void *ref, H5R_type_t ref_type) const;
// Retrieves a dataspace with the region pointed to selected.
hid_t p_get_region(void *ref, H5R_type_t ref_type) const;
// Retrieves a dataspace with the region pointed to selected.
hid_t p_get_region(void *ref, H5R_type_t ref_type) const;
// Verifies that the given id is valid.
bool p_valid_id(const hid_t obj_id) const;

19
c++/src/H5Include.h
View File

@ -13,10 +13,17 @@
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Added this line for CC to compile at this time. Will remove it when
// the problem of "Multiple declaration for RcsId" is fixed. BMR - 10/30/00
#include <hdf5.h>
// This problem is removed. I could replace all #include "H5Include.h"
// by #include <hdf5.h>, but decide not to. BMR - 3/22/01
#include "hdf5.h"
// Define bool type for platforms that don't support bool yet
#ifdef BOOL_NOTDEFINED
#ifdef false
#undef false
#endif
#ifdef true
#undef true
#endif
typedef int bool;
const bool false = 0;
const bool true = 1;
#endif

3
c++/src/H5IntType.h
View File

@ -19,6 +19,7 @@
#ifndef H5_NO_NAMESPACE
namespace H5 {
#endif
class H5_DLLCPP IntType : public AtomType {
public:
// Creates a integer type using a predefined type
@ -34,7 +35,7 @@ class H5_DLLCPP IntType : public AtomType {
void setSign( H5T_sign_t sign ) const;
// Returns this class name
virtual H5std_string fromClass () const { return("IntType"); }
virtual H5std_string fromClass () const { return("IntType"); }
// Default constructor
IntType();

56
c++/src/H5PredType.cpp
View File

@ -178,6 +178,14 @@ const PredType PredType::NATIVE_HBOOL( H5T_NATIVE_HBOOL );
const PredType PredType::NATIVE_INT8( H5T_NATIVE_INT8 );
const PredType PredType::NATIVE_UINT8( H5T_NATIVE_UINT8 );
const PredType PredType::NATIVE_INT16( H5T_NATIVE_INT16 );
const PredType PredType::NATIVE_UINT16( H5T_NATIVE_UINT16 );
const PredType PredType::NATIVE_INT32( H5T_NATIVE_INT32 );
const PredType PredType::NATIVE_UINT32( H5T_NATIVE_UINT32 );
const PredType PredType::NATIVE_INT64( H5T_NATIVE_INT64 );
const PredType PredType::NATIVE_UINT64( H5T_NATIVE_UINT64 );
// LEAST types
#if H5_SIZEOF_INT_LEAST8_T != 0
const PredType PredType::NATIVE_INT_LEAST8( H5T_NATIVE_INT_LEAST8 );
#endif /* H5_SIZEOF_INT_LEAST8_T */
@ -185,8 +193,6 @@ const PredType PredType::NATIVE_INT_LEAST8( H5T_NATIVE_INT_LEAST8 );
const PredType PredType::NATIVE_UINT_LEAST8( H5T_NATIVE_UINT_LEAST8 );
#endif /* H5_SIZEOF_UINT_LEAST8_T */
const PredType PredType::NATIVE_INT16( H5T_NATIVE_INT16 );
const PredType PredType::NATIVE_UINT16( H5T_NATIVE_UINT16 );
#if H5_SIZEOF_INT_LEAST16_T != 0
const PredType PredType::NATIVE_INT_LEAST16( H5T_NATIVE_INT_LEAST16 );
#endif /* H5_SIZEOF_INT_LEAST16_T */
@ -194,8 +200,6 @@ const PredType PredType::NATIVE_INT_LEAST16( H5T_NATIVE_INT_LEAST16 );
const PredType PredType::NATIVE_UINT_LEAST16( H5T_NATIVE_UINT_LEAST16 );
#endif /* H5_SIZEOF_UINT_LEAST16_T */
const PredType PredType::NATIVE_INT32( H5T_NATIVE_INT32 );
const PredType PredType::NATIVE_UINT32( H5T_NATIVE_UINT32 );
#if H5_SIZEOF_INT_LEAST32_T != 0
const PredType PredType::NATIVE_INT_LEAST32( H5T_NATIVE_INT_LEAST32 );
#endif /* H5_SIZEOF_INT_LEAST32_T */
@ -203,8 +207,6 @@ const PredType PredType::NATIVE_INT_LEAST32( H5T_NATIVE_INT_LEAST32 );
const PredType PredType::NATIVE_UINT_LEAST32( H5T_NATIVE_UINT_LEAST32 );
#endif /* H5_SIZEOF_UINT_LEAST32_T */
const PredType PredType::NATIVE_INT64( H5T_NATIVE_INT64 );
const PredType PredType::NATIVE_UINT64( H5T_NATIVE_UINT64 );
#if H5_SIZEOF_INT_LEAST64_T != 0
const PredType PredType::NATIVE_INT_LEAST64( H5T_NATIVE_INT_LEAST64 );
#endif /* H5_SIZEOF_INT_LEAST64_T */
@ -212,16 +214,34 @@ const PredType PredType::NATIVE_INT_LEAST64( H5T_NATIVE_INT_LEAST64 );
const PredType PredType::NATIVE_UINT_LEAST64( H5T_NATIVE_UINT_LEAST64 );
#endif /* H5_SIZEOF_UINT_LEAST64_T */
// These are new types and waiting for enabling with C99; currently,
// the H5T_NATIVE_xxx_FASTn are -1 on sol. 11/14/05
//const PredType PredType::NATIVE_INT_FAST8( H5T_NATIVE_INT_FAST8 );
//const PredType PredType::NATIVE_UINT_FAST8( H5T_NATIVE_UINT_FAST8 );
//const PredType PredType::NATIVE_INT_FAST16( H5T_NATIVE_INT_FAST16 );
//const PredType PredType::NATIVE_UINT_FAST16( H5T_NATIVE_UINT_FAST16 );
//const PredType PredType::NATIVE_INT_FAST32( H5T_NATIVE_INT_FAST32 );
//const PredType PredType::NATIVE_UINT_FAST32( H5T_NATIVE_UINT_FAST32 );
//const PredType PredType::NATIVE_INT_FAST64( H5T_NATIVE_INT_FAST64 );
//const PredType PredType::NATIVE_UINT_FAST64( H5T_NATIVE_UINT_FAST64 );
// FAST types
#if H5_SIZEOF_INT_FAST8_T != 0
const PredType PredType::NATIVE_INT_FAST8( H5T_NATIVE_INT_FAST8 );
#endif /* H5_SIZEOF_INT_FAST8_T */
#if H5_SIZEOF_UINT_FAST8_T != 0
const PredType PredType::NATIVE_UINT_FAST8( H5T_NATIVE_UINT_FAST8 );
#endif /* H5_SIZEOF_UINT_FAST8_T */
#if H5_SIZEOF_INT_FAST16_T != 0
const PredType PredType::NATIVE_INT_FAST16( H5T_NATIVE_INT_FAST16 );
#endif /* H5_SIZEOF_INT_FAST16_T */
#if H5_SIZEOF_UINT_FAST16_T != 0
const PredType PredType::NATIVE_UINT_FAST16( H5T_NATIVE_UINT_FAST16 );
#endif /* H5_SIZEOF_UINT_FAST16_T */
#if H5_SIZEOF_INT_FAST32_T != 0
const PredType PredType::NATIVE_INT_FAST32( H5T_NATIVE_INT_FAST32 );
#endif /* H5_SIZEOF_INT_FAST32_T */
#if H5_SIZEOF_UINT_FAST32_T != 0
const PredType PredType::NATIVE_UINT_FAST32( H5T_NATIVE_UINT_FAST32 );
#endif /* H5_SIZEOF_UINT_FAST32_T */
#if H5_SIZEOF_INT_FAST64_T != 0
const PredType PredType::NATIVE_INT_FAST64( H5T_NATIVE_INT_FAST64 );
#endif /* H5_SIZEOF_INT_FAST64_T */
#if H5_SIZEOF_UINT_FAST64_T != 0
const PredType PredType::NATIVE_UINT_FAST64( H5T_NATIVE_UINT_FAST64 );
#endif /* H5_SIZEOF_UINT_FAST64_T */
#endif // DOXYGEN_SHOULD_SKIP_THIS
//--------------------------------------------------------------------------
@ -239,8 +259,8 @@ PredType& PredType::operator=( const PredType& rhs )
{
if (this != &rhs)
{
copy(rhs);
return(*this);
copy(rhs);
return(*this);
}
}

51
c++/src/H5PredType.h
View File

@ -152,47 +152,70 @@ class H5_DLLCPP PredType : public AtomType {
static const PredType NATIVE_INT8;
static const PredType NATIVE_UINT8;
static const PredType NATIVE_INT16;
static const PredType NATIVE_UINT16;
static const PredType NATIVE_INT32;
static const PredType NATIVE_UINT32;
static const PredType NATIVE_INT64;
static const PredType NATIVE_UINT64;
// LEAST types
#if H5_SIZEOF_INT_LEAST8_T != 0
static const PredType NATIVE_INT_LEAST8;
#endif /* H5_SIZEOF_INT_LEAST8_T */
#if H5_SIZEOF_UINT_LEAST8_T != 0
static const PredType NATIVE_UINT_LEAST8;
#endif /* H5_SIZEOF_UINT_LEAST8_T */
//static const PredType NATIVE_INT_FAST8;
//static const PredType NATIVE_UINT_FAST8;
static const PredType NATIVE_INT16;
static const PredType NATIVE_UINT16;
#if H5_SIZEOF_INT_LEAST16_T != 0
static const PredType NATIVE_INT_LEAST16;
#endif /* H5_SIZEOF_INT_LEAST16_T */
#if H5_SIZEOF_UINT_LEAST16_T != 0
static const PredType NATIVE_UINT_LEAST16;
#endif /* H5_SIZEOF_UINT_LEAST16_T */
//static const PredType NATIVE_INT_FAST16;
//static const PredType NATIVE_UINT_FAST16;
static const PredType NATIVE_INT32;
static const PredType NATIVE_UINT32;
#if H5_SIZEOF_INT_LEAST32_T != 0
static const PredType NATIVE_INT_LEAST32;
#endif /* H5_SIZEOF_INT_LEAST32_T */
#if H5_SIZEOF_UINT_LEAST32_T != 0
static const PredType NATIVE_UINT_LEAST32;
#endif /* H5_SIZEOF_UINT_LEAST32_T */
//static const PredType NATIVE_INT_FAST32;
//static const PredType NATIVE_UINT_FAST32;
static const PredType NATIVE_INT64;
static const PredType NATIVE_UINT64;
#if H5_SIZEOF_INT_LEAST64_T != 0
static const PredType NATIVE_INT_LEAST64;
#endif /* H5_SIZEOF_INT_LEAST64_T */
#if H5_SIZEOF_UINT_LEAST64_T != 0
static const PredType NATIVE_UINT_LEAST64;
#endif /* H5_SIZEOF_UINT_LEAST64_T */
//static const PredType NATIVE_INT_FAST64;
//static const PredType NATIVE_UINT_FAST64;
// FAST types
#if H5_SIZEOF_INT_FAST8_T != 0
static const PredType NATIVE_INT_FAST8;
#endif /* H5_SIZEOF_INT_FAST8_T */
#if H5_SIZEOF_UINT_FAST8_T != 0
static const PredType NATIVE_UINT_FAST8;
#endif /* H5_SIZEOF_UINT_FAST8_T */
#if H5_SIZEOF_INT_FAST16_T != 0
static const PredType NATIVE_INT_FAST16;
#endif /* H5_SIZEOF_INT_FAST16_T */
#if H5_SIZEOF_UINT_FAST16_T != 0
static const PredType NATIVE_UINT_FAST16;
#endif /* H5_SIZEOF_UINT_FAST16_T */
#if H5_SIZEOF_INT_FAST32_T != 0
static const PredType NATIVE_INT_FAST32;
#endif /* H5_SIZEOF_INT_FAST32_T */
#if H5_SIZEOF_UINT_FAST32_T != 0
static const PredType NATIVE_UINT_FAST32;
#endif /* H5_SIZEOF_UINT_FAST32_T */
#if H5_SIZEOF_INT_FAST64_T != 0
static const PredType NATIVE_INT_FAST64;
#endif /* H5_SIZEOF_INT_FAST64_T */
#if H5_SIZEOF_UINT_FAST64_T != 0
static const PredType NATIVE_UINT_FAST64;
#endif /* H5_SIZEOF_UINT_FAST64_T */
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// These dummy functions do not inherit from DataType - they'll

42
c++/src/H5PropList.cpp
View File

@ -70,18 +70,18 @@ PropList::PropList( const PropList& original ) : IdComponent( original ) {}
PropList::PropList( const hid_t plist_id ) : IdComponent(0)
{
if (H5I_GENPROP_CLS == H5Iget_type(plist_id)) {
// call C routine to create the new property
id = H5Pcreate(plist_id);
if( id < 0 )
{
throw PropListIException("PropList constructor", "H5Pcreate failed");
}
// call C routine to create the new property
id = H5Pcreate(plist_id);
if( id < 0 )
{
throw PropListIException("PropList constructor", "H5Pcreate failed");
}
}
else {
if(plist_id==H5P_NO_CLASS)
id=H5P_DEFAULT;
else
id=plist_id;
if(plist_id==H5P_NO_CLASS)
id=H5P_DEFAULT;
else
id=plist_id;
}
}
@ -92,24 +92,26 @@ PropList::PropList( const hid_t plist_id ) : IdComponent(0)
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
void PropList::copy( const PropList& like_plist )
{
// If this object is representing an hdf5 object, close it before
// copying like_plist to it
try {
close();
close();
}
catch (Exception close_error) {
throw FileIException("PropList::copy", close_error.getDetailMsg());
throw PropListIException(inMemFunc("copy"), close_error.getDetailMsg());
}
// call C routine to copy the property list
id = H5Pcopy( like_plist.getId() );
if( id < 0 )
throw PropListIException(inMemFunc("copy"), "H5Pcopy failed");
throw PropListIException(inMemFunc("copy"), "H5Pcopy failed");
}
//--------------------------------------------------------------------------
@ -170,7 +172,7 @@ void PropList::copyProp( PropList& dest, const H5std_string& name ) const
///\param dest - IN: Destination property list or class
///\param src - IN: Source property list or class
///\param name - IN: Name of the property to copy - \c char pointer
///\notes This member function will be removed in the next release
///\note This member function will be removed in the next release
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
@ -621,8 +623,10 @@ PropList PropList::getClassParent() const
///\brief Properly terminates access to this property list.
// Programmer Binh-Minh Ribler - 2000
// Modification
// Replaced resetIdComponent with decRefCount to use C library
// ID reference counting mechanism - June 1, 2004
// - Replaced resetIdComponent() with decRefCount() to use C
// library ID reference counting mechanism - BMR, Jun 1, 2004
// - Replaced decRefCount with close() to let the C library
// handle the reference counting - BMR, Jun 1, 2006
//--------------------------------------------------------------------------
PropList::~PropList()
{
@ -630,7 +634,7 @@ PropList::~PropList()
close();
}
catch (Exception close_error) {
cerr << "PropList::~PropList - " << close_error.getDetailMsg() << endl;
cerr << "PropList::~PropList - " << close_error.getDetailMsg() << endl;
}
}

6
c++/src/H5PropList.h
View File

@ -67,13 +67,13 @@ class H5_DLLCPP PropList : public IdComponent {
// Query the value of a property in a property list.
void getProperty(const char* name, void* value) const;
H5std_string getProperty(const char* name) const;
void getProperty(const H5std_string& name, void* value) const;
H5std_string getProperty(const char* name) const;
H5std_string getProperty(const H5std_string& name) const;
// Set a property's value in a property list.
void setProperty(const char* name, void* charptr) const;
void setProperty(const char* name, const char* value) const;
void setProperty(const char* name, void* value) const;
void setProperty(const char* name, const char* charptr) const;
void setProperty(const char* name, H5std_string& strg) const;
void setProperty(const H5std_string& name, void* value) const;
void setProperty(const H5std_string& name, H5std_string& strg) const;

1
c++/src/H5VarLenType.h
View File

@ -22,6 +22,7 @@
#ifndef H5_NO_NAMESPACE
namespace H5 {
#endif
class H5_DLLCPP VarLenType : public DataType {
public:
// Constructor that creates a variable-length datatype based