mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-12 17:31:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r11206] Purpose: Additional wrapper/Code improvement

Browse Source 
Description:
    Added wrapper for H5Iget_type.
    Added try/catch to many APIs that call private functions so that more
        specific information can be provided at failure.
    Added IdComponent::inMemFunc to help providing specific info.
    Added const to parameters of several functions that missed that.

Platforms tested:
    Linux 2.4 (heping)
    SunOS 5.8 64-bit (sol)
    AIX 5.1 (copper)
    IRIX64 with -n32 (modi4)
    HPUX 11.00 (kelgia)
This commit is contained in:
Binh-Minh Ribler 2005-08-07 22:53:58 -05:00
parent e49bb1feea
commit 07592ad7c3
26 changed files with 606 additions and 182 deletions

151
c++/src/H5AbstractDs.cpp

@ -62,15 +62,24 @@ H5T_class_t AbstractDs::getTypeClass() const
// Gets the datatype used by this dataset or attribute.
// p_get_type calls either H5Dget_type or H5Aget_type depending on
// which object invokes getTypeClass
DataType datatype(p_get_type());
hid_t datatype_id;
try {
datatype_id = p_get_type(); // returned value is already validated
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getTypeClass", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getTypeClass", E.getDetailMsg());
}
// Gets the class of the datatype and validate it before returning
H5T_class_t type_class = H5Tget_class( datatype.getId());
H5T_class_t type_class = H5Tget_class(datatype_id);
if( type_class != H5T_NO_CLASS )
return( type_class );
else
{
throw DataTypeIException("AbstractDs::getTypeClass",
throw DataTypeIException(inMemFunc("getTypeClass"),
"H5Tget_class returns H5T_NO_CLASS");
}
}
@ -85,19 +94,25 @@ H5T_class_t AbstractDs::getTypeClass() const
//--------------------------------------------------------------------------
DataType AbstractDs::getDataType() const
{
// Gets the id of the datatype used by this dataset or attribute.
// p_get_type calls either H5Dget_type or H5Aget_type depending on
// which object invokes getTypeClass
hid_t datatype_id = p_get_type(); // returned value is already validated
// Create and return the DataType object
DataType datatype( datatype_id );
return( datatype );
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getDataType. Then, create and
// return the DataType object
try {
DataType datatype(p_get_type());
return(datatype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getDataType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getDataType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: AbstractDs::getArrayType
///\brief Returns the compound datatype of this abstract dataset which
///\brief Returns the array datatype of this abstract dataset which
/// can be a dataset or an attribute.
///\return ArrayType instance
///\exception H5::DataTypeIException
@ -105,8 +120,20 @@ DataType AbstractDs::getDataType() const
//--------------------------------------------------------------------------
ArrayType AbstractDs::getArrayType() const
{
ArrayType arraytype(p_get_type());
return(arraytype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getArrayType. Then, create and
// return the ArrayType object
try {
ArrayType arraytype(p_get_type());
return(arraytype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getArrayType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getArrayType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -119,8 +146,20 @@ ArrayType AbstractDs::getArrayType() const
//--------------------------------------------------------------------------
CompType AbstractDs::getCompType() const
{
CompType comptype(p_get_type());
return(comptype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getCompType. Then, create and
// return the CompType object
try {
CompType comptype(p_get_type());
return(comptype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getCompType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getCompType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -133,8 +172,20 @@ CompType AbstractDs::getCompType() const
//--------------------------------------------------------------------------
EnumType AbstractDs::getEnumType() const
{
EnumType enumtype(p_get_type());
return(enumtype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getEnumType. Then, create and
// return the EnumType object
try {
EnumType enumtype(p_get_type());
return(enumtype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getEnumType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getEnumType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -147,8 +198,20 @@ EnumType AbstractDs::getEnumType() const
//--------------------------------------------------------------------------
IntType AbstractDs::getIntType() const
{
IntType inttype(p_get_type());
return(inttype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getIntType. Then, create and
// return the IntType object
try {
IntType inttype(p_get_type());
return(inttype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getIntType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getIntType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -161,8 +224,20 @@ IntType AbstractDs::getIntType() const
//--------------------------------------------------------------------------
FloatType AbstractDs::getFloatType() const
{
FloatType floatype(p_get_type());
return(floatype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getFloatType. Then, create and
// return the FloatType object
try {
FloatType floatype(p_get_type());
return(floatype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getFloatType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getFloatType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -175,8 +250,20 @@ FloatType AbstractDs::getFloatType() const
//--------------------------------------------------------------------------
StrType AbstractDs::getStrType() const
{
StrType strtype(p_get_type());
return(strtype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getStrType. Then, create and
// return the StrType object
try {
StrType strtype(p_get_type());
return(strtype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getStrType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getStrType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -189,8 +276,20 @@ StrType AbstractDs::getStrType() const
//--------------------------------------------------------------------------
VarLenType AbstractDs::getVarLenType() const
{
VarLenType varlentype(p_get_type());
return(varlentype);
// Gets the id of the datatype used by this dataset or attribute using
// p_get_type. p_get_type calls either H5Dget_type or H5Aget_type
// depending on which object invokes getVarLenType. Then, create and
// return the VarLenType object
try {
VarLenType varlentype(p_get_type());
return(varlentype);
}
catch (DataSetIException E) {
throw DataTypeIException("DataSet::getVarLenType", E.getDetailMsg());
}
catch (AttributeIException E) {
throw DataTypeIException("Attribute::getVarLenType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------

3
c++/src/H5ArrayType.h

@ -34,6 +34,9 @@ class H5_DLLCPP ArrayType : public DataType {
// Returns the sizes of dimensions of this array datatype.
int getArrayDims(hsize_t* dims);
// Returns this class name
virtual string fromClass () const { return ("ArrayType"); }
// Copy constructor: makes copy of the original object.
ArrayType( const ArrayType& original );

3
c++/src/H5AtomType.h

@ -55,6 +55,9 @@ 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 string fromClass () const { return("AtomType"); }
// Copy constructor - makes copy of the original object
AtomType( const AtomType& original );

3
c++/src/H5Attribute.h

@ -44,6 +44,9 @@ class H5_DLLCPP Attribute : public AbstractDs {
void write(const DataType& mem_type, const void *buf ) const;
void write(const DataType& mem_type, const string& strg ) const;
// Returns this class name
virtual string fromClass () const { return ("Attribute"); }
// Creates a copy of an existing attribute using the attribute id
Attribute( const hid_t attr_id );

147
c++/src/H5CommonFG.cpp

@ -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::FileIException or H5::GroupIException
///\exception 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 string& name, size_t size_hint ) const
/// or another group.
///\param name - IN: Name of the group to open
///\return Group instance
///\exception H5::FileIException or H5::GroupIException
///\exception H5::GroupIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
Group CommonFG::openGroup( const char* name ) const
@ -139,7 +139,7 @@ Group CommonFG::openGroup( const 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::FileIException or H5::GroupIException
///\exception H5::DataSetIException
// 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 string& name, const DataType& data_type,
///\brief Opens an existing dataset at this location.
///\param name - IN: Name of the dataset to open
///\return DataSet instance
///\exception H5::FileIException or H5::GroupIException
///\exception H5::DataSetIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
DataSet CommonFG::openDataSet( const char* name ) const
@ -283,6 +283,11 @@ void CommonFG::unlink( const string& name ) const
///\param src - IN: Object's original name
///\param dst - IN: Object's new name
///\exception H5::FileIException or H5::GroupIException
///\note
/// Exercise care in moving groups as it is possible to render
/// data in a file inaccessible with Group::move. Please refer
/// to the Group Interface in the HDF5 User's Guide at:
/// http://hdf.ncsa.uiuc.edu/HDF5/doc/Groups.html
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void CommonFG::move( const char* src, const char* dst ) const
@ -314,6 +319,10 @@ void CommonFG::move( const string& src, const string& dst ) const
///\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
//--------------------------------------------------------------------------
void CommonFG::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const
{
@ -580,38 +589,6 @@ void CommonFG::unmount( const string& name ) const
unmount( name.c_str() );
}
//--------------------------------------------------------------------------
// Function: CommonFG::p_open_data_type (private)
// Purpose Opens the named datatype and returns the datatype's identifier.
// Return Id of the datatype
// Exception H5::FileIException or H5::GroupIException
// Description
// This private function is used by the member functions
// CommonFG::openXxxType, where Xxx indicates the specific
// datatypes.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
hid_t CommonFG::p_open_data_type( const char* name ) const
{
// Call C function H5Topen to open the named datatype in this group,
// giving either the file or group id
hid_t datatype_id = H5Topen( getLocId(), name );
// If the datatype's opening failed, throw an exception
if( datatype_id < 0 )
{
throwException("openDataType", "H5Topen failed");
}
// No failure, return the datatype id
return( datatype_id );
}
//
// The following member functions use the private function
// p_open_data_type to open a named datatype in this location
//
//--------------------------------------------------------------------------
// Function: CommonFG::openDataType
///\brief Opens the named generic datatype at this location.
@ -622,8 +599,18 @@ hid_t CommonFG::p_open_data_type( const char* name ) const
//--------------------------------------------------------------------------
DataType CommonFG::openDataType( const char* name ) const
{
DataType data_type(p_open_data_type(name));
return( data_type );
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openDataType", "H5Topen failed");
}
// No failure, create and return the DataType object
DataType data_type(type_id);
return(data_type);
}
//--------------------------------------------------------------------------
@ -648,7 +635,17 @@ DataType CommonFG::openDataType( const string& name ) const
//--------------------------------------------------------------------------
ArrayType CommonFG::openArrayType( const char* name ) const
{
ArrayType array_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openArrayType", "H5Topen failed");
}
// No failure, create and return the ArrayType object
ArrayType array_type (type_id);
return(array_type);
}
@ -674,7 +671,17 @@ ArrayType CommonFG::openArrayType( const string& name ) const
//--------------------------------------------------------------------------
CompType CommonFG::openCompType( const char* name ) const
{
CompType comp_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openCompType", "H5Topen failed");
}
// No failure, create and return the CompType object
CompType comp_type(type_id);
return(comp_type);
}
@ -700,7 +707,17 @@ CompType CommonFG::openCompType( const string& name ) const
//--------------------------------------------------------------------------
EnumType CommonFG::openEnumType( const char* name ) const
{
EnumType enum_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openEnumType", "H5Topen failed");
}
// No failure, create and return the EnumType object
EnumType enum_type(type_id);
return(enum_type);
}
@ -726,7 +743,17 @@ EnumType CommonFG::openEnumType( const string& name ) const
//--------------------------------------------------------------------------
IntType CommonFG::openIntType( const char* name ) const
{
IntType int_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openIntType", "H5Topen failed");
}
// No failure, create and return the IntType object
IntType int_type(type_id);
return(int_type);
}
@ -752,7 +779,17 @@ IntType CommonFG::openIntType( const string& name ) const
//--------------------------------------------------------------------------
FloatType CommonFG::openFloatType( const char* name ) const
{
FloatType float_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openFloatType", "H5Topen failed");
}
// No failure, create and return the FloatType object
FloatType float_type(type_id);
return(float_type);
}
@ -778,7 +815,17 @@ FloatType CommonFG::openFloatType( const string& name ) const
//--------------------------------------------------------------------------
StrType CommonFG::openStrType( const char* name ) const
{
StrType str_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openStrType", "H5Topen failed");
}
// No failure, create and return the StrType object
StrType str_type(type_id);
return(str_type);
}
@ -804,7 +851,17 @@ StrType CommonFG::openStrType( const string& name ) const
//--------------------------------------------------------------------------
VarLenType CommonFG::openVarLenType( const char* name ) const
{
VarLenType varlen_type(p_open_data_type(name));
// Call C function H5Topen to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen(getLocId(), name);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
{
throwException("openVarLenType", "H5Topen failed");
}
// No failure, create and return the VarLenType object
VarLenType varlen_type(type_id);
return(varlen_type);
}

7
c++/src/H5CommonFG.h

@ -141,10 +141,13 @@ class H5_DLLCPP CommonFG {
VarLenType openVarLenType(const char* name) const;
VarLenType openVarLenType(const string& name) const;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/// For subclasses, H5File and Group, to return the correct
/// object id, i.e. file or group id.
virtual hid_t getLocId() const = 0;
#endif // DOXYGEN_SHOULD_SKIP_THIS
/// For subclasses, H5File and Group, to throw appropriate exception.
virtual void throwException(const string func_name, const string msg) const = 0;
@ -154,10 +157,6 @@ class H5_DLLCPP CommonFG {
// Noop destructor.
virtual ~CommonFG();
private:
// Common code for member functions openXxxType
hid_t p_open_data_type(const char* name) const;
}; // end of CommonFG declaration
#ifndef H5_NO_NAMESPACE

78
c++/src/H5CompType.cpp

@ -216,9 +216,9 @@ hid_t CompType::p_get_member_type(unsigned member_num) const
return( member_type_id );
else
{
// p_get_member_type is private, use caller's function name for api
throw DataTypeIException("CompType::getMemberDataType",
"H5Tget_member_type failed");
// p_get_member_type is private, caller will catch this exception
// then throw another with appropriate API name
throw DataTypeIException("", "H5Tget_member_type failed");
}
}
@ -233,8 +233,13 @@ hid_t CompType::p_get_member_type(unsigned member_num) const
//--------------------------------------------------------------------------
DataType CompType::getMemberDataType( unsigned member_num ) const
{
DataType datatype(p_get_member_type(member_num));
return(datatype);
try {
DataType datatype(p_get_member_type(member_num));
return(datatype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberDataType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -248,8 +253,13 @@ DataType CompType::getMemberDataType( unsigned member_num ) const
//--------------------------------------------------------------------------
ArrayType CompType::getMemberArrayType( unsigned member_num ) const
{
ArrayType arraytype(p_get_member_type(member_num));
return(arraytype);
try {
ArrayType arraytype(p_get_member_type(member_num));
return(arraytype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberArrayType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -263,8 +273,13 @@ ArrayType CompType::getMemberArrayType( unsigned member_num ) const
//--------------------------------------------------------------------------
EnumType CompType::getMemberEnumType( unsigned member_num ) const
{
EnumType enumtype(p_get_member_type(member_num));
return(enumtype);
try {
EnumType enumtype(p_get_member_type(member_num));
return(enumtype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberEnumType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -278,8 +293,13 @@ EnumType CompType::getMemberEnumType( unsigned member_num ) const
//--------------------------------------------------------------------------
CompType CompType::getMemberCompType( unsigned member_num ) const
{
CompType comptype(p_get_member_type(member_num));
return(comptype);
try {
CompType comptype(p_get_member_type(member_num));
return(comptype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberCompType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -293,8 +313,13 @@ CompType CompType::getMemberCompType( unsigned member_num ) const
//--------------------------------------------------------------------------
IntType CompType::getMemberIntType( unsigned member_num ) const
{
IntType inttype(p_get_member_type(member_num));
return(inttype);
try {
IntType inttype(p_get_member_type(member_num));
return(inttype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberIntType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -308,8 +333,13 @@ IntType CompType::getMemberIntType( unsigned member_num ) const
//--------------------------------------------------------------------------
FloatType CompType::getMemberFloatType( unsigned member_num ) const
{
FloatType floatype(p_get_member_type(member_num));
return(floatype);
try {
FloatType floatype(p_get_member_type(member_num));
return(floatype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberFloatType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -323,8 +353,13 @@ FloatType CompType::getMemberFloatType( unsigned member_num ) const
//--------------------------------------------------------------------------
StrType CompType::getMemberStrType( unsigned member_num ) const
{
StrType strtype(p_get_member_type(member_num));
return(strtype);
try {
StrType strtype(p_get_member_type(member_num));
return(strtype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberStrType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -338,8 +373,13 @@ StrType CompType::getMemberStrType( unsigned member_num ) const
//--------------------------------------------------------------------------
VarLenType CompType::getMemberVarLenType( unsigned member_num ) const
{
VarLenType varlentype(p_get_member_type(member_num));
return(varlentype);
try {
VarLenType varlentype(p_get_member_type(member_num));
return(varlentype);
}
catch (DataTypeIException E) {
throw DataTypeIException("CompType::getMemberVarLenType", E.getDetailMsg());
}
}
/* old style of getMemberType - using overloads; new style above

3
c++/src/H5CompType.h

@ -90,6 +90,9 @@ class H5_DLLCPP CompType : public DataType {
// Recursively removes padding from within this compound datatype.
void pack() const;
// Returns this class name
virtual string fromClass () const { return ("CompType"); }
// Default constructor
CompType();

58
c++/src/H5DataSet.cpp

@ -349,7 +349,8 @@ int DataSet::iterateElems( void* buf, const DataType& type, const DataSpace& spa
///\par Description
/// For more information, please see the Description section in
/// C layer Reference Manual at:
/// http:
///\par
/// http://hdf.ncsa.uiuc.edu/HDF5/doc/RM_H5D.html#Dataset-Extend
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DataSet::extend( const hsize_t* size ) const
@ -413,12 +414,17 @@ void DataSet::fillMemBuf(void *buf, DataType& buf_type, DataSpace& space)
///\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::DataSetIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* DataSet::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_type) const
{
return(p_reference(name, dataspace.getId(), ref_type));
try {
return(p_reference(name, dataspace.getId(), ref_type));
}
catch (IdComponentException E) {
throw DataSetIException("DataSet::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -428,7 +434,7 @@ void* DataSet::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_
/// 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::DataSetIException
///\par Description
// This function passes H5R_OBJECT and -1 to the protected
// function for it to pass to the C API H5Rcreate
@ -437,7 +443,25 @@ void* DataSet::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_
//--------------------------------------------------------------------------
void* DataSet::Reference(const char* name) const
{
return(p_reference(name, -1, H5R_OBJECT));
try {
return(p_reference(name, -1, H5R_OBJECT));
}
catch (IdComponentException E) {
throw DataSetIException("DataSet::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: DataSet::Reference
///\brief This is an overloaded function, provided for your convenience.
/// 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 - \c std::string
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* DataSet::Reference(const string& name) const
{
return(Reference(name.c_str()));
}
//--------------------------------------------------------------------------
@ -445,17 +469,22 @@ void* DataSet::Reference(const char* name) const
///\brief Retrieves the type of object that an object reference points to.
///\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:
///\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
// Exception H5::IdComponentException
///\exception H5::DataSetIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
H5G_obj_t DataSet::getObjType(void *ref, H5R_type_t ref_type) const
{
return(p_get_obj_type(ref, ref_type));
try {
return(p_get_obj_type(ref, ref_type));
}
catch (IdComponentException E) {
throw DataSetIException("DataSet::getObjType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -465,13 +494,18 @@ H5G_obj_t DataSet::getObjType(void *ref, H5R_type_t ref_type) const
/// to H5R_DATASET_REGION
///\param ref - IN: Reference to get region of
///\return DataSpace instance
///\exception H5::IdComponentException
///\exception H5::DataSetIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
DataSpace DataSet::getRegion(void *ref, H5R_type_t ref_type) const
{
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
try {
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
}
catch (IdComponentException E) {
throw DataSetIException("DataSet::getRegion", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -488,7 +522,7 @@ void DataSet::close()
{
throw DataSetIException("DataSet::close", "H5Dclose failed");
}
// reset the id because the group that it represents is now closed
// reset the id because the dataset that it represents is now closed
id = 0;
}

4
c++/src/H5DataSet.h

@ -81,6 +81,10 @@ class H5_DLLCPP DataSet : public AbstractDs {
// Creates a reference to a named Hdf5 object in this object.
void* Reference(const char* name) const;
void* Reference(const string& name) const;
// Returns this class name
virtual string fromClass () const { return ("DataSet"); }
// Creates a copy of an existing DataSet using its id.
DataSet(const hid_t existing_id);

96
c++/src/H5DataType.cpp

@ -107,7 +107,7 @@ void DataType::copy( const DataType& like_type )
decRefCount();
}
catch (Exception close_error) {
throw DataTypeIException("DataType::copy", close_error.getDetailMsg());
throw DataTypeIException(inMemFunc("copy"), close_error.getDetailMsg());
}
}
@ -115,7 +115,7 @@ void DataType::copy( const DataType& like_type )
id = H5Tcopy( like_type.getId() );
if( id < 0 )
throw DataTypeIException("DataType::copy", "H5Tcopy failed");
throw DataTypeIException(inMemFunc("copy"), "H5Tcopy failed");
}
//--------------------------------------------------------------------------
@ -155,8 +155,7 @@ bool DataType::operator==(const DataType& compared_type ) const
return false;
else
{
throw DataTypeIException("DataType::operator==",
"H5Tequal returns negative value");
throw DataTypeIException(inMemFunc("operator=="), "H5Tequal returns negative value");
}
}
@ -177,7 +176,7 @@ void DataType::commit(CommonFG& loc, const char* name) const
herr_t ret_value = H5Tcommit( loc_id, name, id );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::commit", "H5Tcommit failed");
throw DataTypeIException(inMemFunc("commit"), "H5Tcommit failed");
}
}
@ -211,7 +210,7 @@ bool DataType::committed() const
return false;
else
{
throw DataTypeIException("DataType::committed", "H5Tcommitted return negative value");
throw DataTypeIException(inMemFunc("committed"), "H5Tcommitted return negative value");
}
}
@ -231,7 +230,7 @@ H5T_conv_t DataType::find( const DataType& dest, H5T_cdata_t **pcdata ) const
H5T_conv_t func = H5Tfind( id, dest.getId(), pcdata );
if( func == NULL )
{
throw DataTypeIException("DataType::find", "H5Tfind returns a NULL function");
throw DataTypeIException(inMemFunc("find"), "H5Tfind returns a NULL function");
}
return( func );
}
@ -260,7 +259,7 @@ void DataType::convert( const DataType& dest, size_t nelmts, void *buf, void *ba
ret_value = H5Tconvert( id, dest_id, nelmts, buf, background, plist_id );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::convert", "H5Tconvert failed");
throw DataTypeIException(inMemFunc("convert"), "H5Tconvert failed");
}
}
@ -284,7 +283,7 @@ void DataType::lock() const
herr_t ret_value = H5Tlock( id );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::lock", "H5Tlock failed");
throw DataTypeIException(inMemFunc("lock"), "H5Tlock failed");
}
}
@ -302,8 +301,7 @@ H5T_class_t DataType::getClass() const
// Return datatype class identifier if successful
if( type_class == H5T_NO_CLASS )
{
throw DataTypeIException("DataType::getClass",
"H5Tget_class returns H5T_NO_CLASS");
throw DataTypeIException(inMemFunc("getClass"), "H5Tget_class returns H5T_NO_CLASS");
}
return( type_class );
}
@ -321,8 +319,7 @@ size_t DataType::getSize() const
size_t type_size = H5Tget_size( id );
if( type_size <= 0 ) // valid data types are never zero size
{
throw DataTypeIException("DataType::getSize",
"H5Tget_size returns invalid datatype size");
throw DataTypeIException(inMemFunc("getSize"), "H5Tget_size returns invalid datatype size");
}
return( type_size );
}
@ -349,7 +346,7 @@ DataType DataType::getSuper() const
}
else
{
throw DataTypeIException("DataType::getSuper", "H5Tget_super failed");
throw DataTypeIException(inMemFunc("getSuper"), "H5Tget_super failed");
}
}
@ -377,7 +374,7 @@ void DataType::registerFunc( H5T_pers_t pers, const char* name, const DataType&
herr_t ret_value = H5Tregister( pers, name, id, dest_id, func );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::registerFunc", "H5Tregister failed");
throw DataTypeIException(inMemFunc("registerFunc"), "H5Tregister failed");
}
}
@ -414,7 +411,7 @@ void DataType::unregister( H5T_pers_t pers, const char* name, const DataType& de
herr_t ret_value = H5Tunregister( pers, name, id, dest_id, func );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::unregister", "H5Tunregister failed");
throw DataTypeIException(inMemFunc("unregister"), "H5Tunregister failed");
}
}
@ -444,7 +441,7 @@ void DataType::setTag( const char* tag ) const
herr_t ret_value = H5Tset_tag( id, tag );
if( ret_value < 0 )
{
throw DataTypeIException("DataType::setTag", "H5Tset_tag failed");
throw DataTypeIException(inMemFunc("setTag"), "H5Tset_tag failed");
}
}
@ -481,8 +478,7 @@ string DataType::getTag() const
}
else
{
throw DataTypeIException("DataType::getTag",
"H5Tget_tag returns NULL for tag");
throw DataTypeIException(inMemFunc("getTag"), "H5Tget_tag returns NULL for tag");
}
}
@ -504,8 +500,7 @@ bool DataType::detectClass(H5T_class_t cls) const
return false;
else
{
throw DataTypeIException("DataType::detectClass",
"H5Tdetect_class returns negative value");
throw DataTypeIException(inMemFunc("detectClass"), "H5Tdetect_class returns negative value");
}
}
@ -526,8 +521,7 @@ bool DataType::isVariableStr() const
return false;
else
{
throw DataTypeIException("DataType::isVariableStr",
"H5Tis_variable_str returns negative value");
throw DataTypeIException(inMemFunc("isVariableStr"), "H5Tis_variable_str returns negative value");
}
}
@ -538,12 +532,17 @@ bool DataType::isVariableStr() 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::DataTypeIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* DataType::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_type) const
{
return(p_reference(name, dataspace.getId(), ref_type));
try {
return(p_reference(name, dataspace.getId(), ref_type));
}
catch (IdComponentException E) {
throw DataTypeIException(inMemFunc("Reference"), E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -553,7 +552,7 @@ void* DataType::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref
/// 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::DataTypeIException
///\par Description
// This function passes H5R_OBJECT and -1 to the protected
// function for it to pass to the C API H5Rcreate
@ -562,7 +561,26 @@ void* DataType::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref
//--------------------------------------------------------------------------
void* DataType::Reference(const char* name) const
{
return(p_reference(name, -1, H5R_OBJECT));
try {
return(p_reference(name, -1, H5R_OBJECT));
}
catch (IdComponentException E) {
throw DataTypeIException(inMemFunc("Reference"), E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: DataType::Reference
///\brief This is an overloaded function, provided for your convenience.
/// 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 - \c std::string
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* DataType::Reference(const string& name) const
{
return(Reference(name.c_str()));
}
//--------------------------------------------------------------------------
@ -575,12 +593,17 @@ void* DataType::Reference(const char* 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::DataTypeIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
H5G_obj_t DataType::getObjType(void *ref, H5R_type_t ref_type) const
{
return(p_get_obj_type(ref, ref_type));
try {
return(p_get_obj_type(ref, ref_type));
}
catch (IdComponentException E) {
throw DataTypeIException(inMemFunc("getObjType"), E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -589,13 +612,18 @@ H5G_obj_t DataType::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::DataTypeIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
DataSpace DataType::getRegion(void *ref, H5R_type_t ref_type) const
{
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
try {
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
}
catch (IdComponentException E) {
throw DataTypeIException(inMemFunc("getRegion"), E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -613,7 +641,7 @@ void DataType::close()
herr_t ret_value = H5Tclose(id);
if( ret_value < 0 )
{
throw DataTypeIException("DataType::close", "H5Tclose failed");
throw DataTypeIException(inMemFunc("close"), "H5Tclose failed");
}
// reset the id because the datatype that it represents is now closed
id = 0;
@ -638,7 +666,7 @@ DataType::~DataType()
decRefCount();
}
catch (Exception close_error) {
cerr << "DataType::~DataType - " << close_error.getDetailMsg() << endl;
cerr << inMemFunc("~DataType - ") << close_error.getDetailMsg() << endl;
}
}
}

3
c++/src/H5DataType.h

@ -92,6 +92,7 @@ class H5_DLLCPP DataType : public H5Object {
// Creates a reference to a named Hdf5 object in this object.
void* Reference(const char* name) const;
void* Reference(const string& name) const;
// Creates a reference to a named Hdf5 object or to a dataset region
// in this object.
@ -103,6 +104,8 @@ 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;
virtual string fromClass () const { return ("DataType"); }
// Creates a copy of an existing DataType using its id
DataType( const hid_t type_id, bool predtype = false );

2
c++/src/H5EnumType.cpp

@ -240,7 +240,7 @@ int EnumType::getNmembers() const
int num_members = H5Tget_nmembers( id );
if( num_members < 0 )
{
throw DataTypeIException("CompType::getNmembers",
throw DataTypeIException("EnumType::getNmembers",
"H5Tget_nmembers returns negative number of members");
}
return( num_members );

3
c++/src/H5EnumType.h

@ -56,6 +56,9 @@ class H5_DLLCPP EnumType : public DataType {
void valueOf( const char* name, void *value ) const;
void valueOf( const string& name, void *value ) const;
// Returns this class name
virtual string fromClass () const { return ("EnumType"); }
// Default constructor
EnumType();

50
c++/src/H5File.cpp

@ -427,7 +427,12 @@ void H5File::getVFDHandle(void **file_handle) const
//--------------------------------------------------------------------------
string H5File::getFileName() const
{
return(p_get_file_name());
try {
return(p_get_file_name());
}
catch (IdComponentException E) {
throw FileIException("H5File::getFileName", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -444,7 +449,12 @@ string H5File::getFileName() const
//--------------------------------------------------------------------------
void* H5File::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_type) const
{
return(p_reference(name, dataspace.getId(), ref_type));
try {
return(p_reference(name, dataspace.getId(), ref_type));
}
catch (IdComponentException E) {
throw FileIException("H5File::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -466,7 +476,25 @@ void* H5File::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_t
//--------------------------------------------------------------------------
void* H5File::Reference(const char* name) const
{
return(p_reference(name, -1, H5R_OBJECT));
try {
return(p_reference(name, -1, H5R_OBJECT));
}
catch (IdComponentException E) {
throw FileIException("H5File::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: H5File::Reference
///\brief This is an overloaded function, provided for your convenience.
/// 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 - \c std::string
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* H5File::Reference(const string& name) const
{
return(Reference(name.c_str()));
}
//--------------------------------------------------------------------------
@ -484,7 +512,12 @@ void* H5File::Reference(const char* name) const
//--------------------------------------------------------------------------
H5G_obj_t H5File::getObjType(void *ref, H5R_type_t ref_type) const
{
return(p_get_obj_type(ref, ref_type));
try {
return(p_get_obj_type(ref, ref_type));
}
catch (IdComponentException E) {
throw FileIException("H5File::getObjType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -498,8 +531,13 @@ H5G_obj_t H5File::getObjType(void *ref, H5R_type_t ref_type) const
//--------------------------------------------------------------------------
DataSpace H5File::getRegion(void *ref, H5R_type_t ref_type) const
{
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
try {
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
}
catch (IdComponentException E) {
throw FileIException("H5File::getRegion", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------

4
c++/src/H5File.h

@ -81,6 +81,10 @@ class H5_DLLCPP H5File : public IdComponent, public CommonFG {
// Creates a reference to a named Hdf5 object in this object.
void* Reference(const char* name) const;
void* Reference(const string& name) const;
// Returns this class name
virtual string fromClass () const { return ("H5File"); }
// Throw file exception.
virtual void throwException(const string func_name, const string msg) const;

3
c++/src/H5FloatType.h

@ -52,6 +52,9 @@ class H5_DLLCPP FloatType : public AtomType {
// Sets the mantissa normalization of a floating-point datatype.
void setNorm( H5T_norm_t norm ) const;
// Returns this class name
virtual string fromClass () const { return ("FloatType"); }
// Default constructor
FloatType();

53
c++/src/H5Group.cpp

@ -81,12 +81,17 @@ Group::Group( const hid_t group_id ) : H5Object( group_id ) {}
///\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::GroupIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
void* Group::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_type) const
{
return(p_reference(name, dataspace.getId(), ref_type));
try {
return(p_reference(name, dataspace.getId(), ref_type));
}
catch (IdComponentException E) {
throw GroupIException("Group::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -96,7 +101,7 @@ void* Group::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_ty
/// 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::GroupIException
///\par Description
// This function passes H5R_OBJECT and -1 to the protected
// function for it to pass to the C API H5Rcreate
@ -105,7 +110,25 @@ void* Group::Reference(const char* name, DataSpace& dataspace, H5R_type_t ref_ty
//--------------------------------------------------------------------------
void* Group::Reference(const char* name) const
{
return(p_reference(name, -1, H5R_OBJECT));
try {
return(p_reference(name, -1, H5R_OBJECT));
}
catch (IdComponentException E) {
throw GroupIException("Group::Reference", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
// Function: Group::Reference
///\brief This is an overloaded function, provided for your convenience.
/// 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
//--------------------------------------------------------------------------
void* Group::Reference(const string& name) const
{
return(Reference(name.c_str()));
}
//--------------------------------------------------------------------------
@ -113,17 +136,22 @@ void* Group::Reference(const char* name) const
///\brief Retrieves the type of object that an object reference points to.
///\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:
///\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
// Exception H5::IdComponentException
///\exception H5::GroupIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
H5G_obj_t Group::getObjType(void *ref, H5R_type_t ref_type) const
{
return(p_get_obj_type(ref, ref_type));
try {
return(p_get_obj_type(ref, ref_type));
}
catch (IdComponentException E) {
throw GroupIException("Group::getObjType", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------
@ -132,13 +160,18 @@ H5G_obj_t Group::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::GroupIException
// Programmer Binh-Minh Ribler - May, 2004
//--------------------------------------------------------------------------
DataSpace Group::getRegion(void *ref, H5R_type_t ref_type) const
{
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
try {
DataSpace dataspace(p_get_region(ref, ref_type));
return(dataspace);
}
catch (IdComponentException E) {
throw GroupIException("Group::getRegion", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------

4
c++/src/H5Group.h

@ -37,6 +37,10 @@ class H5_DLLCPP Group : public H5Object, public CommonFG {
// Creates a reference to a named Hdf5 object in this object.
void* Reference(const char* name) const;
void* Reference(const string& name) const;
// Returns this class name
virtual string fromClass () const { return ("Group"); }
// Throw group exception.
virtual void throwException(const string func_name, const string msg) const;

70
c++/src/H5IdComponent.cpp

@ -49,7 +49,7 @@ IdComponent::IdComponent( const IdComponent& original )
///\brief Increment reference counter for a given id.
// Programmer Binh-Minh Ribler - May 2005
//--------------------------------------------------------------------------
void IdComponent::incRefCount(hid_t obj_id) const
void IdComponent::incRefCount(const hid_t obj_id) const
{
if (p_valid_id(obj_id))
if (H5Iinc_ref(obj_id) < 0)
@ -74,7 +74,7 @@ void IdComponent::incRefCount() const
// Added the check for ref counter to give a little more info
// on why H5Idec_ref fails in some cases - BMR 5/19/2005
//--------------------------------------------------------------------------
void IdComponent::decRefCount(hid_t obj_id) const
void IdComponent::decRefCount(const hid_t obj_id) const
{
if (p_valid_id(obj_id))
if (H5Idec_ref(obj_id) < 0)
@ -102,7 +102,7 @@ void IdComponent::decRefCount() const
///\return Reference count
// Programmer Binh-Minh Ribler - May 2005
//--------------------------------------------------------------------------
int IdComponent::getCounter(hid_t obj_id) const
int IdComponent::getCounter(const hid_t obj_id) const
{
int counter = 0;
if (p_valid_id(obj_id))
@ -125,6 +125,29 @@ int IdComponent::getCounter() const
return (getCounter(id));
}
//--------------------------------------------------------------------------
// 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
/// \li \c H5I_DATASPACE
/// \li \c H5I_DATASET
/// \li \c H5I_ATTR
/// \li or \c H5I_BADID, if no valid type can be determined or the
/// input object id is invalid.
// Programmer Binh-Minh Ribler - Jul, 2005
//--------------------------------------------------------------------------
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
else
return id_type; // valid type
}
//--------------------------------------------------------------------------
// Function: IdComponent::operator=
///\brief Assignment operator.
@ -166,7 +189,7 @@ IdComponent& IdComponent::operator=( const IdComponent& rhs )
// Then the object's id is reset to the new id.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void IdComponent::setId( hid_t new_id )
void IdComponent::setId(const hid_t new_id)
{
// handling references to this id
decRefCount();
@ -222,6 +245,26 @@ IdComponent::~IdComponent() {
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//--------------------------------------------------------------------------
// Function: IdComponent::inMemFunc
///\brief Makes and returns string "<class-name>::<func_name>"
///\param func_name - Name of the function where failure occurs
// Description
/// Concatenates the class name of this object with the
/// passed-in function name to create a string that indicates
/// where the failure occurs. The class-name is provided by
/// fromClass(). This string will be used by a base class when
/// an exception is thrown.
// Programmer Binh-Minh Ribler - Aug 6, 2005
//--------------------------------------------------------------------------
string IdComponent::inMemFunc(const char* func_name) const
{
string full_name = func_name;
full_name.insert(0, "::");
full_name.insert(0, fromClass());
return (full_name);
}
//--------------------------------------------------------------------------
// Function: IdComponent default constructor - private
///\brief Default constructor.
@ -230,7 +273,7 @@ IdComponent::~IdComponent() {
IdComponent::IdComponent() : id(-1) {}
//--------------------------------------------------------------------------
// Function: IdComponent::p_get_file_name
// Function: IdComponent::p_get_file_name (protected)
// Purpose: Gets the name of the file, in which this object belongs.
// Exception: H5::IdComponentException
// Description:
@ -247,8 +290,7 @@ string IdComponent::p_get_file_name() const
// If H5Aget_name returns a negative value, raise an exception,
if( name_size < 0 )
{
throw IdComponentException("IdComponent::p_get_file_name",
"H5Fget_name failed");
throw IdComponentException("", "H5Fget_name failed");
}
// Call H5Fget_name again to get the actual file name
@ -258,8 +300,7 @@ string IdComponent::p_get_file_name() const
// Check for failure again
if( name_size < 0 )
{
throw IdComponentException("IdComponent::p_get_file_name",
"H5Fget_name failed");
throw IdComponentException("", "H5Fget_name failed");
}
// Convert the C file name and return
@ -285,8 +326,7 @@ void* IdComponent::p_reference(const char* name, hid_t space_id, H5R_type_t ref_
herr_t ret_value = H5Rcreate(ref, id, name, ref_type, space_id);
if (ret_value < 0)
{
throw IdComponentException("IdComponent::p_reference",
"H5Rcreate failed");
throw IdComponentException("", "H5Rcreate failed");
}
return(ref);
}
@ -310,8 +350,7 @@ H5G_obj_t IdComponent::p_get_obj_type(void *ref, H5R_type_t ref_type) const
H5G_obj_t obj_type = H5Rget_obj_type(id, ref_type, ref);
if (obj_type == H5G_UNKNOWN)
{
throw IdComponentException("IdComponent::p_get_obj_type",
"H5R_get_obj_type failed");
throw IdComponentException("", "H5R_get_obj_type failed");
}
return(obj_type);
}
@ -332,8 +371,7 @@ hid_t IdComponent::p_get_region(void *ref, H5R_type_t ref_type) const
hid_t space_id = H5Rget_region(id, ref_type, ref);
if (space_id < 0)
{
throw IdComponentException("IdComponent::p_get_region",
"H5Rget_region failed");
throw IdComponentException("", "H5Rget_region failed");
}
return(space_id);
}
@ -349,7 +387,7 @@ hid_t IdComponent::p_get_region(void *ref, H5R_type_t ref_type) const
// Return true if id is valid, false, otherwise
// Programmer Binh-Minh Ribler - May, 2005
//--------------------------------------------------------------------------
bool IdComponent::p_valid_id(hid_t obj_id) const
bool IdComponent::p_valid_id(const hid_t obj_id) const
{
H5I_type_t id_type = H5Iget_type(obj_id);
if (id_type <= H5I_BADID || id_type >= H5I_NTYPES)

23
c++/src/H5IdComponent.h

@ -25,24 +25,25 @@ namespace H5 {
class H5_DLLCPP IdComponent {
public:
// Increment reference counter.
void incRefCount(hid_t obj_id) const;
void incRefCount(const hid_t obj_id) const;
void incRefCount() const;
// Decrement reference counter.
void decRefCount(hid_t obj_id) const;
void decRefCount(const hid_t obj_id) const;
void decRefCount() const;
// Get the reference counter to this identifier.
int getCounter(hid_t obj_id) const;
int getCounter(const hid_t obj_id) const;
int getCounter() const;
// Returns an HDF object type, given the object id.
static H5I_type_t getHDFObjType(const hid_t obj_id);
// Assignment operator.
IdComponent& operator=( const IdComponent& rhs );
//void reset();
// Sets the identifier of this object to a new value.
void setId( hid_t new_id );
void setId(const hid_t new_id);
// Creates an object to hold an HDF5 identifier.
IdComponent( const hid_t h5_id );
@ -57,6 +58,14 @@ class H5_DLLCPP IdComponent {
// Pure virtual function for there are various H5*close for the
// subclasses.
virtual void close() = 0;
// Makes and returns the string "<class-name>::<func_name>";
// <class-name> is returned by fromClass().
string inMemFunc(const char* func_name) const;
// Returns this class name.
virtual string fromClass() const {return ("IdComponent");}
#endif // DOXYGEN_SHOULD_SKIP_THIS
// Destructor
@ -89,7 +98,7 @@ class H5_DLLCPP IdComponent {
hid_t p_get_region(void *ref, H5R_type_t ref_type) const;
// Verifies that the given id is valid.
bool p_valid_id(hid_t obj_id) const;
bool p_valid_id(const hid_t obj_id) const;
#endif // DOXYGEN_SHOULD_SKIP_THIS

3
c++/src/H5IntType.h

@ -33,6 +33,9 @@ class H5_DLLCPP IntType : public AtomType {
// Sets the sign proprety for an integer type.
void setSign( H5T_sign_t sign ) const;
// Returns this class name
virtual string fromClass () const { return("IntType"); }
// Default constructor
IntType();

7
c++/src/H5Object.cpp

@ -327,7 +327,12 @@ void H5Object::flush(H5F_scope_t scope ) const
//--------------------------------------------------------------------------
string H5Object::getFileName() const
{
return(p_get_file_name());
try {
return(p_get_file_name());
}
catch (IdComponentException E) {
throw FileIException("H5Object::getFileName", E.getDetailMsg());
}
}
//--------------------------------------------------------------------------

4
c++/src/H5PropList.cpp

@ -112,6 +112,7 @@ void PropList::copy( const PropList& like_plist )
// Function: PropList::operator=
///\brief Assignment operator.
///\param rhs - IN: Reference to the existing property list
///\return Reference to PropList instance
///\exception H5::PropListIException
// Description
// Makes a copy of the property list on the right hand side
@ -320,6 +321,7 @@ void PropList::getProperty(const char* name, void* value) const
/// accepts.
///\param name - IN: Name of property to query - \c char pointer
///\return The property that is a \c std::string.
///\exception H5::PropListIException
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------
string PropList::getProperty(const char* name) const
@ -344,7 +346,7 @@ string PropList::getProperty(const char* name) const
///\brief This is an overloaded member function, provided for convenience.
/// It differs from the above function only in what arguments it
/// accepts.
///\param name - IN: Name of property to query - \c str::string
///\param name - IN: Name of property to query - \c std::string
///\param value - OUT: Pointer to the buffer for the property value
// Programmer: Binh-Minh Ribler - April, 2004
//--------------------------------------------------------------------------

3
c++/src/H5StrType.h

@ -46,6 +46,9 @@ class H5_DLLCPP StrType : public AtomType {
// Defines the storage mechanism for character strings.
void setStrpad(H5T_str_t strpad) const;
// Returns this class name
virtual string fromClass () const { return ("StrType"); }
// default constructor
StrType();

3
c++/src/H5VarLenType.h

@ -28,6 +28,9 @@ class H5_DLLCPP VarLenType : public DataType {
// on the specified base type.
VarLenType(const DataType* base_type);
// Returns this class name
virtual string fromClass () const { return ("VarLenType"); }
// Copy constructor: makes copy of the original object.
VarLenType( const VarLenType& original );