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

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)

26 files changed, 606 insertions, 182 deletions

diff --git a/c++/src/H5AbstractDs.cpp b/c++/src/H5AbstractDs.cpp
index 9e54d94..9e02181 100644
--- a/c++/src/H5AbstractDs.cpp
+++ b/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());
+   }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5ArrayType.h b/c++/src/H5ArrayType.h
index 3f1ddc5..023998d 100644
--- a/c++/src/H5ArrayType.h
+++ b/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 );
 
diff --git a/c++/src/H5AtomType.h b/c++/src/H5AtomType.h
index f9b43c4..9cca02c 100644
--- a/c++/src/H5AtomType.h
+++ b/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 );
 
diff --git a/c++/src/H5Attribute.h b/c++/src/H5Attribute.h
index cf6f5c4..73a5612 100644
--- a/c++/src/H5Attribute.h
+++ b/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 );
 
diff --git a/c++/src/H5CommonFG.cpp b/c++/src/H5CommonFG.cpp
index 9660096..767286e 100644
--- a/c++/src/H5CommonFG.cpp
+++ b/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
 {
@@ -581,38 +590,6 @@ void CommonFG::unmount( const string& name ) const
 }
 
 //--------------------------------------------------------------------------
-// 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.
 ///\param	name  - IN: Name of the datatype to open
@@ -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);
 }
 
diff --git a/c++/src/H5CommonFG.h b/c++/src/H5CommonFG.h
index 1ad18f2..0bb8e67 100644
--- a/c++/src/H5CommonFG.h
+++ b/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
diff --git a/c++/src/H5CompType.cpp b/c++/src/H5CompType.cpp
index 2007891..aed4b58 100644
--- a/c++/src/H5CompType.cpp
+++ b/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 
diff --git a/c++/src/H5CompType.h b/c++/src/H5CompType.h
index d018c13..d548043 100644
--- a/c++/src/H5CompType.h
+++ b/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();
 
diff --git a/c++/src/H5DataSet.cpp b/c++/src/H5DataSet.cpp
index 765b1e5..7ab5179 100644
--- a/c++/src/H5DataSet.cpp
+++ b/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;
 }
 
diff --git a/c++/src/H5DataSet.h b/c++/src/H5DataSet.h
index a15103a..24e88a7 100644
--- a/c++/src/H5DataSet.h
+++ b/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);
diff --git a/c++/src/H5DataType.cpp b/c++/src/H5DataType.cpp
index 96aee12..28668a46 100644
--- a/c++/src/H5DataType.cpp
+++ b/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;
         }
     }
 }  
diff --git a/c++/src/H5DataType.h b/c++/src/H5DataType.h
index f6a30ff..c135845 100644
--- a/c++/src/H5DataType.h
+++ b/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 );
 
diff --git a/c++/src/H5EnumType.cpp b/c++/src/H5EnumType.cpp
index 9ba71bf..abd9c51 100644
--- a/c++/src/H5EnumType.cpp
+++ b/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 );
diff --git a/c++/src/H5EnumType.h b/c++/src/H5EnumType.h
index f88b337..0313acb 100644
--- a/c++/src/H5EnumType.h
+++ b/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();
 
diff --git a/c++/src/H5File.cpp b/c++/src/H5File.cpp
index 985fc72..361d448 100644
--- a/c++/src/H5File.cpp
+++ b/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());
+   }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5File.h b/c++/src/H5File.h
index f9c1667..3b7ffaf 100644
--- a/c++/src/H5File.h
+++ b/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;
diff --git a/c++/src/H5FloatType.h b/c++/src/H5FloatType.h
index bdc2f6f..bc30963 100644
--- a/c++/src/H5FloatType.h
+++ b/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();
 
diff --git a/c++/src/H5Group.cpp b/c++/src/H5Group.cpp
index 384ea1e..1d587c8 100644
--- a/c++/src/H5Group.cpp
+++ b/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());
+   }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5Group.h b/c++/src/H5Group.h
index 9a7b33b..a0ed933 100644
--- a/c++/src/H5Group.h
+++ b/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;
diff --git a/c++/src/H5IdComponent.cpp b/c++/src/H5IdComponent.cpp
index aed355d..15a4898 100644
--- a/c++/src/H5IdComponent.cpp
+++ b/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))
@@ -126,6 +126,29 @@ 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:
+///		\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.
 ///\param	rhs - IN: Reference to the existing object
@@ -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();
@@ -223,6 +246,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.
 // Programmer	Binh-Minh Ribler - 2000
@@ -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)
diff --git a/c++/src/H5IdComponent.h b/c++/src/H5IdComponent.h
index e50eb2a..33fa7d2 100644
--- a/c++/src/H5IdComponent.h
+++ b/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
 
diff --git a/c++/src/H5IntType.h b/c++/src/H5IntType.h
index efbed39..ab43d0f 100644
--- a/c++/src/H5IntType.h
+++ b/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();
 
diff --git a/c++/src/H5Object.cpp b/c++/src/H5Object.cpp
index 2ef3345..2ca26c9 100644
--- a/c++/src/H5Object.cpp
+++ b/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());
+   }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5PropList.cpp b/c++/src/H5PropList.cpp
index c4b96c7..b448830 100644
--- a/c++/src/H5PropList.cpp
+++ b/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
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5StrType.h b/c++/src/H5StrType.h
index 9e4483e..fbf4ac4 100644
--- a/c++/src/H5StrType.h
+++ b/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();
 
diff --git a/c++/src/H5VarLenType.h b/c++/src/H5VarLenType.h
index ded95c6..e93e6fb 100644
--- a/c++/src/H5VarLenType.h
+++ b/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 );