[svn-r2897] Purpose:

	C++ API for 1.3.x branch

Description:
	The *.C and *.h files named different than those in 1.2.x.
	They are in the form: 'H5' + classname, or just classname if
	the classname is already prefixed with 'H5' to avoid ambiguity
	in documentation context.  This version has several hidden bugs
	fixed and an improvement on the reference counting approach.
	The classes and their inheritance structure are listed below:
	---------------------------------------
	H5Library
	Exception
	RefCounter
	IdComponent
		H5File
		DataSpace
		H5Object
			Group
			AbstractDs
				DataSet
				Attribute
			DataType
				PredType
				EnumType
				CompType
				AtomType
					StrType
					IntType
					FloatType
		PropList
			FileCreatPropList
			FileAccPropList
			DSetCreatPropList
			DSetMemXferPropList
	---------------------------------------
	IdComponent uses RefCounter to keep track of opened objects
	so proper termination of HDF5 objects can be maintained.
	Each class has a .h file containing the class declaration and
	a .C file containing its definition.  In addition to the classes
	files, the following files do not have class information:

	- H5Cpp.h: header file to be included in user's application
	- H5Idtemplates.h: contains a template function used by several classes
	- H5Classes.h: contains forward class declarations
	- H5CommonFG.*: contains common code used by classes H5File and Group
	- H5Include.h: contains the hdf5.h header file and the #undef RCSID
		to work around the problem: multiple defined RcsId
	- H5Alltypes.h: simply serves as a container to hold the header
		files of all datatypes to simplify the header file inclusion

Platforms:
	Solaris (arabica) and Linux

55 files changed, 6782 insertions, 0 deletions

diff --git a/c++/src/H5AbstractDs.C b/c++/src/H5AbstractDs.C
new file mode 100644
index 0000000..5424bdb
--- /dev/null
+++ b/c++/src/H5AbstractDs.C
@@ -0,0 +1,132 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5AbstractDs.h"
+#include "H5Alltypes.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+AbstractDs::AbstractDs() : H5Object() {}
+
+// Constructor that takes an id
+AbstractDs::AbstractDs( const hid_t ds_id ) : H5Object( ds_id ) {}
+
+// Copy constructor: makes copy of the original object; simply invokes
+// base-class copy constructor.
+AbstractDs::AbstractDs( const AbstractDs& original ) : H5Object( original ) {}
+
+// Returns the class of the datatype that is used by this dataset
+H5T_class_t AbstractDs::getTypeClass() const
+{
+   // Gets the datatype used by this dataset or attribute.
+   // p_getType calls either H5Dget_type or H5Aget_type depending on 
+   // which object invokes getTypeClass
+   DataType datatype( p_getType());
+
+   // Gets the class of the datatype and validate it before returning
+   H5T_class_t type_class = H5Tget_class( datatype.getId());
+   if( type_class != H5T_NO_CLASS )
+      return( type_class );
+   else
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the generic datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+DataType AbstractDs::getDataType() const
+{
+   // Gets the id of the datatype used by this dataset or attribute.
+   // p_getType calls either H5Dget_type or H5Aget_type depending on 
+   // which object invokes getTypeClass
+   hid_t datatype_id = p_getType();  // returned value is already validated
+
+   // Create and return the DataType object
+   DataType datatype( datatype_id );
+   return( datatype );
+}
+
+// Returns the enumeration datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+EnumType AbstractDs::getEnumType() const
+{
+   EnumType enumtype( p_getType());
+   return( enumtype );
+}
+
+// Returns the compound datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+CompType AbstractDs::getCompType() const
+{
+   CompType comptype( p_getType());
+   return( comptype );
+}
+
+// Returns the integer datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+IntType AbstractDs::getIntType() const
+{
+   IntType inttype( p_getType());
+   return( inttype );
+}
+
+// Returns the floating-point datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+FloatType AbstractDs::getFloatType() const
+{
+   FloatType floatype( p_getType());
+   return( floatype );
+}
+
+// Returns the string datatype of this abstract dataset which 
+// can be a dataset or an attribute.
+StrType AbstractDs::getStrType() const
+{
+   StrType strtype( p_getType());
+   return( strtype );
+}
+
+/* This version of getDataType is older style.  New style above doesn't
+use overloading.  Remove it when knowing for sure that the other way
+is prefered
+// Gets the specific datatype of this abstract dataset which can be a 
+// dataset or an attribute.  Several overloaded getDataType's below
+// are for specific sub-datatypes.
+void AbstractDs::getDataType( EnumType& enumtype ) const
+{
+   enumtype.setId( p_getType());
+}
+
+void AbstractDs::getDataType( CompType& comptype ) const
+{
+   comptype.setId( p_getType());
+}
+
+void AbstractDs::getDataType( IntType& inttype ) const
+{
+   inttype.setId( p_getType());
+}
+
+void AbstractDs::getDataType( FloatType& floatype ) const
+{
+   floatype.setId( p_getType());
+}
+
+void AbstractDs::getDataType( StrType& strtype ) const
+{
+   strtype.setId( p_getType());
+}
+end of old style of getDataType */
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5AbstractDs.h b/c++/src/H5AbstractDs.h
new file mode 100644
index 0000000..49aafa9
--- /dev/null
+++ b/c++/src/H5AbstractDs.h
@@ -0,0 +1,53 @@
+#ifndef _AbstractDs_H
+#define _AbstractDs_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+class AbstractDs : public H5Object {
+   public:
+	// Copy constructor
+	AbstractDs( const AbstractDs& original );
+
+	// Gets the dataspace of this abstract dataset - pure virtual
+	virtual DataSpace getSpace() const = 0;
+
+        // Gets the class of the datatype that is used by this abstract 
+	// dataset        
+	H5T_class_t getTypeClass() const;
+
+	// Gets a copy the datatype of this abstract dataset.  Note that 
+	// this datatype is a generic one and can only be accessed via 
+	// generic member functions, i.e., member functions belong to 
+	// DataType.  To get specific datatype, i.e. EnumType, 
+	// FloatType, etc..., use the specific functions instead .
+	DataType getDataType() const;
+
+        // Gets a copy of the specific datatype of this abstract dataset -
+	// overloading for subtypes.
+        EnumType getEnumType() const;
+        CompType getCompType() const;
+        IntType getIntType() const;
+        FloatType getFloatType() const;
+        StrType getStrType() const;
+
+	virtual ~AbstractDs() {}; 
+
+   protected:
+	// Default constructor
+	AbstractDs();
+
+	// Constructor that takes an attribute id or a dataset id.
+	AbstractDs( const hid_t ds_id );
+
+   private:
+	// This member function is implemented by DataSet and Attribute
+	virtual hid_t p_getType() const = 0;
+
+	// This member function is implemented by DataSet and Attribute
+        virtual void p_close() const = 0;
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif // _AbstractDs_H
diff --git a/c++/src/H5Alltypes.h b/c++/src/H5Alltypes.h
new file mode 100644
index 0000000..11af047
--- /dev/null
+++ b/c++/src/H5Alltypes.h
@@ -0,0 +1,11 @@
+// This header file simply serves as a container to hold the
+// header files of all datatypes.  It simplifies the header
+// file including in the code.
+
+#include "H5DataType.h"
+#include "H5AtomType.h"
+#include "H5EnumType.h"
+#include "H5IntType.h"
+#include "H5FloatType.h"
+#include "H5StrType.h"
+#include "H5CompType.h"
diff --git a/c++/src/H5AtomType.C b/c++/src/H5AtomType.C
new file mode 100644
index 0000000..bab1ed3
--- /dev/null
+++ b/c++/src/H5AtomType.C
@@ -0,0 +1,143 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AtomType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+AtomType::AtomType() : DataType() {}
+
+// Constructor that takes an existing id 
+AtomType::AtomType( const hid_t existing_id ) : DataType( existing_id ) {}
+
+// Copy constructor: makes a copy of the original AtomType object.
+AtomType::AtomType( const AtomType& original ) : DataType( original ) {}
+
+// Sets the total size for an atomic datatype. 
+void AtomType::setSize( size_t size ) const
+{
+   // Call C routine H5Tset_size to set the total size
+   herr_t ret_value = H5Tset_size( id, size );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the byte order of an atomic datatype.  Inheritance class???
+H5T_order_t AtomType::getOrder( string& order_string ) const
+{
+   // Call C routine to get the byte ordering
+   H5T_order_t type_order = H5Tget_order( id );
+
+   // return a byte order constant if successful
+   if( type_order == H5T_ORDER_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   if( type_order == H5T_ORDER_LE )
+      order_string = "Little endian byte ordering (0)";
+   else if( type_order == H5T_ORDER_BE )
+      order_string = "Big endian byte ordering (1)";
+   else if( type_order == H5T_ORDER_VAX )
+      order_string = "VAX mixed byte ordering (2)";
+   return( type_order );
+}
+
+// Sets the byte ordering of an atomic datatype.  Inheritance class???
+void AtomType::setOrder( H5T_order_t order ) const
+{
+   // Call C routine to set the byte ordering
+   herr_t ret_value = H5Tset_order( id, order );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the precision of an atomic datatype. 
+size_t AtomType::getPrecision() const
+{
+   size_t num_signi_bits = H5Tget_precision( id );  // C routine
+
+   // returns number of significant bits if successful
+   if( num_signi_bits == 0 )
+   {
+      throw DataTypeIException();
+   }
+   return( num_signi_bits );
+}
+
+// Sets the precision of an atomic datatype. 
+void AtomType::setPrecision( size_t precision ) const
+{
+   // Call C routine to set the datatype precision
+   herr_t ret_value = H5Tset_precision( id, precision );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the bit offset of the first significant bit. 
+size_t AtomType::getOffset() const
+{
+   size_t offset = H5Tget_offset( id );  // C routine
+
+   // returns a positive offset value if successful
+   if( offset == 0 )
+   {
+      throw DataTypeIException();
+   }
+   return( offset );
+}
+
+// Sets the bit offset of the first significant bit. 
+void AtomType::setOffset( size_t offset ) const
+{
+   // Call C routine to set the bit offset
+   herr_t ret_value = H5Tset_offset( id, offset );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the padding type of the least and most-significant bit padding. 
+// these two are for Opaque type
+//void AtomType::getPad( H5T_pad_t& lsb, H5T_pad_t& msb ) const
+//{
+   // Call C routine to get the padding type
+   //herr_t ret_value = H5Tget_pad( id, &lsb, &msb );
+   //if( ret_value < 0 )
+   //{
+      //throw DataTypeIException();
+   //}
+//}
+
+// Sets the least and most-significant bits padding types
+//void AtomType::setPad( H5T_pad_t lsb, H5T_pad_t msb ) const
+//{
+   // Call C routine to set the padding type
+   //herr_t ret_value = H5Tset_pad( id, lsb, msb );
+   //if( ret_value < 0 )
+   //{
+      //throw DataTypeIException();
+   //}
+//}
+
+// This destructor terminates access to the datatype; it calls ~DataType
+AtomType::~AtomType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5AtomType.h b/c++/src/H5AtomType.h
new file mode 100644
index 0000000..165cbf5
--- /dev/null
+++ b/c++/src/H5AtomType.h
@@ -0,0 +1,52 @@
+#ifndef _H5AtomType_H
+#define _H5AtomType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+class AtomType : public DataType {
+   public:
+	// Copy constructor - makes copy of the original object
+	AtomType( const AtomType& original );
+
+	// Sets the total size for an atomic datatype. 
+	void setSize( size_t size ) const;
+
+	// Returns the byte order of an atomic datatype. 
+	H5T_order_t getOrder( string& order_string ) const;
+
+	// Sets the byte ordering of an atomic datatype. 
+	void setOrder( H5T_order_t order ) const;
+
+	// Returns the precision of an atomic datatype. 
+	size_t getPrecision() const;
+
+	// Sets the precision of an atomic datatype. 
+	void setPrecision( size_t precision ) const;
+
+	// Retrieves the bit offset of the first significant bit. 
+	size_t getOffset() const;
+
+	// Sets the bit offset of the first significant bit. 
+	void setOffset( size_t offset ) const;
+
+	// The followings will go into Opaque type when completed
+	// Retrieves the padding type of the least and most-significant bit padding. 
+	// void getPad( H5T_pad_t& lsb, H5T_pad_t& msb ) const;
+
+	// Sets the least and most-significant bits padding types
+	// void setPad( H5T_pad_t lsb, H5T_pad_t msb ) const;
+
+	virtual ~AtomType();
+
+   protected:
+	// Default constructor
+	AtomType();
+
+	// Constructor that takes an existing id - for predefined type
+	AtomType( const hid_t existing_id );
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Attribute.C b/c++/src/H5Attribute.C
new file mode 100644
index 0000000..b38267c
--- /dev/null
+++ b/c++/src/H5Attribute.C
@@ -0,0 +1,122 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5Exception.h"
+#include "H5RefCounter.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5AbstractDs.h"
+#include "H5Attribute.h"
+#include "H5DataType.h"
+#include "H5DataSpace.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Copy constructor: makes a copy of the original object; simply invokes
+// the base class copy constructor.
+Attribute::Attribute( const Attribute& original ) : AbstractDs( original ) {};
+
+// Creates a copy of an existing attribute using an id
+Attribute::Attribute( const hid_t attr_id ) : AbstractDs( attr_id ) {}
+
+// Writes data to this attribute.
+void Attribute::write( const DataType& mem_type, void *buf ) const
+{
+   herr_t ret_value = H5Awrite( id, mem_type.getId(), buf );
+   if( ret_value < 0 )
+   {
+      throw AttributeIException();
+   }
+}
+
+// Reads data from this attribute.
+void Attribute::read( const DataType& mem_type, void *buf ) const
+{
+   herr_t ret_value = H5Aread( id, mem_type.getId(), buf );
+   if( ret_value < 0 )
+   {
+      throw AttributeIException();
+   }
+}
+
+// Gets a copy of the dataspace for this attribute.
+DataSpace Attribute::getSpace() const
+{
+   // Calls C function H5Aget_space to get the id of the dataspace
+   hid_t dataspace_id = H5Aget_space( id );
+
+   // If the dataspace id is valid, create and return the DataSpace object
+   if( dataspace_id > 0 )
+   {
+      DataSpace dataspace( dataspace_id );
+      return( dataspace );
+   }
+   else
+   {
+      throw AttributeIException();
+   }
+}
+
+// This private member function calls the C API to get the generic datatype
+// of the datatype that is used by this attribute.  This function is used
+// by the overloaded functions getDataType defined in AbstractDs for the 
+// generic datatype and specific sub-types.
+hid_t Attribute::p_getType() const
+{
+   hid_t type_id = H5Aget_type( id );
+   if( type_id > 0 )
+      return( type_id );
+   else
+   {
+      throw AttributeIException();
+   }
+}
+
+// Gets the name of this attribute.
+string Attribute::getName( size_t buf_size ) const
+{
+   char* name_C = new char[buf_size+1];  // temporary C-string for C API
+
+   // Calls C routine H5Aget_name to get the name of the attribute
+   herr_t name_size = H5Aget_name( id, buf_size, name_C );
+
+   // If H5Aget_name returns a negative value, raise an exception,
+   if( name_size < 0 )
+   {
+      throw AttributeIException();
+   }
+   // otherwise, create the string to hold the attribute name and return it
+   string name = string( name_C );
+   delete name_C;
+   return( name );
+}
+
+// This private function calls the C API H5Aclose to close this attribute.
+// Used by the IdComponent::reset.
+void Attribute::p_close() const
+{
+   herr_t ret_value = H5Aclose( id );
+   if( ret_value < 0 )
+   {
+      throw AttributeIException();
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+Attribute::~Attribute()
+{
+   // The attribute id will be closed properly
+   resetIdComponent( this );
+}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5Attribute.h b/c++/src/H5Attribute.h
new file mode 100644
index 0000000..d04e351
--- /dev/null
+++ b/c++/src/H5Attribute.h
@@ -0,0 +1,47 @@
+#ifndef _H5Attribute_H
+#define _H5Attribute_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class Attribute : public AbstractDs {
+
+   public:
+	// Copy constructor: makes a copy of an existing Attribute object.
+	Attribute( const Attribute& original );
+
+	// Writes data to this attribute.
+	void write(const DataType& mem_type, void *buf ) const;
+
+	// Reads data from this attribute.
+	void read( const DataType& mem_type, void *buf ) const;
+
+	// Gets a copy of the dataspace for this attribute.
+	virtual DataSpace getSpace() const;
+
+	// Gets the name of this attribute.
+	string getName( size_t buf_size ) const;
+
+	// do not inherit iterateAttrs from H5Object
+	int iterateAttrs() { return 0; }
+
+	// Used by the API to appropriately close a attribute
+	virtual void p_close() const;
+
+        // Creates a copy of an existing attribute using the attribute id
+        Attribute( const hid_t attr_id );
+
+	virtual ~Attribute();
+
+   private:
+	// This function contains the common code that is used by 
+	// getTypeClass and various API functions getXxxType 
+	// defined in AbstractDs for generic datatype and specific 
+	// sub-types
+	virtual hid_t p_getType() const;
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Classes.h b/c++/src/H5Classes.h
new file mode 100644
index 0000000..89e11dc
--- /dev/null
+++ b/c++/src/H5Classes.h
@@ -0,0 +1,36 @@
+#ifndef _H5Classes_H
+#define _H5Classes_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+	class Exception;
+	class ReferenceCounter;
+	class IdComponent;
+	class H5Object;
+	class PropList;
+	class FileCreatPropList;
+	class FileAccPropList;
+	class DSetCreatPropList;
+	class DSetMemXferPropList;
+	class DTypePropList;
+	class DataType;
+	class DataSpace;
+	class AtomType;
+	class PredType;
+	class EnumType;
+	class IntType;
+	class FloatType;
+	class StrType;
+	class CompType;
+	//class RefType;
+	class AbstractDs;
+	class DataSet;
+	class Group;
+	class H5File;
+	class Attribute;
+	class H5Library;
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5CommonFG.C b/c++/src/H5CommonFG.C
new file mode 100644
index 0000000..6ece682
--- /dev/null
+++ b/c++/src/H5CommonFG.C
@@ -0,0 +1,285 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5FaccProp.h"
+#include "H5FcreatProp.h"
+#include "H5DxferProp.h"
+#include "H5DcreatProp.h"
+#include "H5Group.h"
+#include "H5AbstractDs.h"
+#include "H5DataSpace.h"
+#include "H5DataSet.h"
+#include "H5File.h"
+#include "H5Alltypes.h"
+
+// Since several compilers do not have support template functions, the
+// code in H5templates.h are modified to become the common code defined
+// in this file.  The common functions use the hdf5 id that is provided
+// by the appropriate objects.
+// October 2000
+
+// There are a few comments that are common to most of the functions
+// defined in this file so they are listed here.
+// - when a failure returned by the C API, the functions will 
+//   throw an exception, called File_GroupException, so Group or File can 
+//   catch it and throw the appropriate exception to the user's application,
+//   i.e., GroupInterfaceException or FileInterfaceException.
+// June 2000
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+// Creates a new group at this location which can be a file or another group.
+Group createGroupT( const hid_t loc_id, const string name, size_t size_hint )
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Call C routine H5Gcreate to create the named group, giving the 
+   // location id which can be a file id or a group id
+   hid_t group_id = H5Gcreate( loc_id, name_C, size_hint );
+
+   // If the group id is valid, create and return the Group object
+   if( group_id > 0 )
+   {
+      Group group( group_id );
+      return( group );
+   }
+   else
+   {
+      throw File_GroupException();
+   }
+}
+
+// Opens an existing group in a location which can be a file or another group
+Group openGroupT( const hid_t loc_id, const string name )
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Call C routine H5Gopen to open the named group, giving the 
+   // location id which can be a file id or a group id
+   hid_t group_id = H5Gopen( loc_id, name_C );
+
+   // If the group id is valid, create and return the Group object
+   if( group_id > 0 )
+   {
+      Group group( group_id );
+      return( group );
+   }
+   else
+   {
+      throw File_GroupException();
+   }
+}
+
+// Creates a new dataset at this location.
+DataSet createDataSetT( const hid_t loc_id, const string name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist )
+{
+   // Convert the dataset's name in C++ string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Obtain identifiers for C API
+   hid_t type_id = data_type.getId();
+   hid_t space_id = data_space.getId();
+   hid_t create_plist_id = create_plist.getId();
+
+   // Call C routine H5Dcreate to create the named dataset
+   hid_t dataset_id = H5Dcreate( loc_id, name_C, type_id, space_id, create_plist_id );
+
+   // If the dataset id is valid, create and return the DataSet object
+   if( dataset_id > 0 )
+   {
+      DataSet dataset( dataset_id );
+      return( dataset );
+   }
+   else
+   {
+      throw File_GroupException();
+   }
+}
+
+// Opens an existing dataset at this location.
+DataSet openDataSetT( const hid_t loc_id, const string name )
+{
+   // Convert the dataset's name in C++ string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Call C function H5Dopen to open the specified dataset, giving
+   // the location id and the dataset's name 
+   hid_t dataset_id = H5Dopen( loc_id, name_C );
+
+   // If the dataset id is valid, create and return the DataSet object
+   if( dataset_id > 0 )
+   {
+      DataSet dataset( dataset_id );
+      return( dataset );
+   }
+   else
+   {
+      throw File_GroupException();
+   }
+}
+
+// Creates a link of the specified type from new_name to current_name;
+// both names are interpreted relative to the specified location id 
+void linkT( const hid_t loc_id, H5G_link_t link_type, const string curr_name, const string new_name )
+{
+   // Convert string to C-string
+   const char* curr_name_C, *new_name_C;
+   curr_name_C = curr_name.c_str();  // refers to contents of curr_name as a C-str
+   new_name_C = new_name.c_str();  // refers to contents of new_name as a C-str
+
+   herr_t ret_value = H5Glink( loc_id, link_type, curr_name_C, new_name_C );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Removes the specified name at this location.
+void unlinkT( const hid_t loc_id, const string name )
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   herr_t ret_value = H5Gunlink( loc_id, name_C );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Renames an object at this location.
+void moveT( const hid_t loc_id, const string src, const string dst )
+{
+   // Convert string to C-string
+   const char* src_C, *dst_C;
+   src_C = src.c_str();  // refers to contents of src as a C-str
+   dst_C = dst.c_str();  // refers to contents of dst as a C-str
+
+   herr_t ret_value = H5Gmove( loc_id, src_C, dst_C );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Returns information about an object
+void getObjinfoT( const hid_t loc_id, const string name, hbool_t follow_link, H5G_stat_t& statbuf )
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   herr_t ret_value = H5Gget_objinfo( loc_id, name_C, follow_link, &statbuf );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Returns the name of the object that the symbolic link points to.
+string getLinkvalT( const hid_t loc_id, const string name, size_t size )
+{
+   // Convert string to C-string - name_C refers to the contents of name 
+   // as a C string
+   const char* name_C = name.c_str();
+
+   char* value_C = new char[size+1];  // temporary C-string for C API
+
+   herr_t ret_value = H5Gget_linkval( loc_id, name_C, size, value_C );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+   string value = string( value_C );
+   delete value_C;
+   return( value );
+}
+
+// Sets the comment for an object specified by its name
+void setCommentT( const hid_t loc_id, const string name, const string comment )
+{
+   // Convert strings to C-strings
+   const char* name_C, *comment_C;
+   name_C = name.c_str();  // refers to the contents of name as a C-str
+   comment_C = comment.c_str();  // refers to the contents of comment as a C-str
+   herr_t ret_value = H5Gset_comment( loc_id, name_C, comment_C );
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Retrieves comment for specified object
+string getCommentT( const hid_t loc_id, const string name, size_t bufsize )
+{
+   // Convert string to C-string - name_C refers to the contents of name 
+   // as a C string
+   const char* name_C = name.c_str();
+
+   // temporary C-string for the object's comment
+   char* comment_C = new char[bufsize+1]; 
+
+   herr_t ret_value = H5Gget_comment( loc_id, name_C, bufsize, comment_C );
+
+   // if H5Gget_comment returns SUCCEED, return the string comment
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+   string comment = string( comment_C );
+   delete comment_C;
+   return( comment );
+}
+
+// Mounts the file 'child' onto this group
+void mountT( const hid_t loc_id, const string name, hid_t child_id, PropList& plist )
+{
+   // Obtain identifiers for C API
+   hid_t plist_id = plist.getId();
+
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Call C routine H5Fmount to do the mouting
+   herr_t ret_value = H5Fmount( loc_id, name_C, child_id, plist_id );
+
+   // Raise exception if H5Fmount returns negative value
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+
+// Unmounts the file named 'name' from this parent group
+void unmountT( const hid_t loc_id, const string name )
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   // Call C routine H5Fmount to do the mouting
+   herr_t ret_value = H5Funmount( loc_id, name_C );
+
+   // Raise exception if H5Funmount returns negative value
+   if( ret_value < 0 )
+   {
+      throw File_GroupException();
+   }
+}
+#ifndef H5_NO_NAMESPACE
+}
+#endif
diff --git a/c++/src/H5CommonFG.h b/c++/src/H5CommonFG.h
new file mode 100644
index 0000000..68c6bec
--- /dev/null
+++ b/c++/src/H5CommonFG.h
@@ -0,0 +1,62 @@
+/*
+These functions provide code that are common to both H5File and Group.
+Some of the member functions of these two classes call a common function
+and provide it a file or group id to perform a task that can be done on
+either an H5File or Group instance. 10/31/00
+
+The name of the functions ends with a T because these functions were
+template functions until it was realized that more than one of our
+supported platforms have not supported template functions.
+*/
+
+#ifndef _CommonFG_H
+#define _CommonFG_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Creates a new group at this location which can be a file or another group.
+Group createGroupT( const hid_t loc_id, const string name, size_t size_hint );
+
+// Opens an existing group in a location which can be a file or another group
+Group openGroupT( const hid_t loc_id, const string name );
+
+// Creates a new dataset at this location.
+DataSet createDataSetT( const hid_t loc_id, const string name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist );
+
+// Opens an existing dataset at this location.
+DataSet openDataSetT( const hid_t loc_id, const string name );
+
+// Creates a link of the specified type from new_name to current_name;
+// both names are interpreted relative to the specified location id
+void linkT( const hid_t loc_id, H5G_link_t link_type, const string curr_name, const string new_name );
+
+// Removes the specified name at this location.
+void unlinkT( const hid_t loc_id, const string name );
+
+// Renames an object at this location.
+void moveT( const hid_t loc_id, const string src, const string dst );
+
+// Returns information about an object
+void getObjinfoT( const hid_t loc_id, const string name, hbool_t follow_link, H5G_stat_t& statbuf );
+
+// Returns the name of the object that the symbolic link points to.
+string getLinkvalT( const hid_t loc_id, const string name, size_t size );
+
+// Sets the comment for an object specified by its name
+void setCommentT( const hid_t loc_id, const string name, const string comment );
+
+// Retrieves comment for specified object
+string getCommentT( const hid_t loc_id, const string name, size_t bufsize );
+
+// Mounts the file 'child' onto this group
+void mountT( const hid_t loc_id, const string name, hid_t child_id, PropList& plist );
+
+// Unmounts the file named 'name' from this parent group
+void unmountT( const hid_t loc_id, const string name );
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
+
diff --git a/c++/src/H5CompType.C b/c++/src/H5CompType.C
new file mode 100644
index 0000000..634d817
--- /dev/null
+++ b/c++/src/H5CompType.C
@@ -0,0 +1,225 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5Alltypes.h"
+#include "H5AbstractDs.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5DataSet.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Creates a new compound datatype
+CompType::CompType( size_t size ) : DataType( H5T_COMPOUND, size ) {}
+
+// Creates a compound datatype using an existing id
+CompType::CompType( const hid_t existing_id ) : DataType( existing_id ) {}
+
+// Default constructor
+CompType::CompType() : DataType() {}
+
+// Copy constructor: makes copy of the original CompType object
+CompType::CompType( const CompType& original ) : DataType( original ) {}
+
+// Gets the compound datatype of the specified dataset - reimplement this
+CompType::CompType( const DataSet& dataset ) : DataType()
+{
+   // Calls C function H5Dget_type to get the id of the datatype
+   id = H5Dget_type( dataset.getId() );
+
+   // If the datatype id is invalid, throw exception
+   if( id <= 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Retrieves the number of members in this compound datatype. 
+int CompType::getNmembers() const
+{
+   int num_members = H5Tget_nmembers( id );
+   if( num_members < 0 )
+   {
+      throw DataTypeIException();
+   }
+   return( num_members );
+}
+
+// Retrieves the name of a member of this compound datatype. 
+string CompType::getMemberName( int member_num ) const
+{
+   char* member_name_C = H5Tget_member_name( id, member_num );
+   if( member_name_C == NULL )  // should this be returned also???
+   {
+      throw DataTypeIException();
+   }
+   string member_name = string( member_name_C );
+   return( member_name );
+}
+
+// Retrieves the offset of a member of a compound datatype. 
+size_t CompType::getMemberOffset( int member_num ) const
+{
+   size_t offset = H5Tget_member_offset( id, member_num );
+   // Q. said: for now, 0 is not a failure
+   //if( offset == 0 )
+   //{
+      //throw DataTypeIException();
+   //}
+   return( offset );
+}
+
+// Returns the dimensionality of the member. 
+int CompType::getMemberDims( int member_num, size_t* dims, int* perm ) const
+{
+   throw DataTypeIException( "Error: getMemberDims is no longer supported." );
+}
+
+// Gets the type class of the specified member.
+H5T_class_t CompType::getMemberClass( int member_num ) const
+{
+   // get the member datatype first
+   hid_t member_type_id = H5Tget_member_type( id, member_num );
+   if( member_type_id <= 0 )
+   {
+      throw DataTypeIException();
+   }
+
+   // then get its class
+   H5T_class_t member_class = H5Tget_class( member_type_id );
+   if( member_class == H5T_NO_CLASS )
+   {
+      throw DataTypeIException();
+   }
+   return( member_class );
+}
+
+// This private member function calls the C API to get the identifier 
+// of the specified member.  It is used by the getMemberXxxType
+// below for the sub-types.
+hid_t CompType::p_getMemberType( int member_num ) const
+{
+   hid_t member_type_id = H5Tget_member_type( id, member_num );
+   if( member_type_id > 0 )
+      return( member_type_id );
+   else
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the datatype of the specified member in this compound datatype. 
+DataType CompType::getMemberDataType( int member_num ) const
+{
+   DataType datatype( p_getMemberType( member_num )); 
+   return( datatype );
+}
+
+EnumType CompType::getMemberEnumType( int member_num ) const
+{
+   EnumType enumtype( p_getMemberType( member_num )); 
+   return( enumtype );
+}
+
+CompType CompType::getMemberCompType( int member_num ) const
+{
+   CompType comptype( p_getMemberType( member_num )); 
+   return( comptype );
+}
+
+IntType CompType::getMemberIntType( int member_num ) const
+{
+   IntType inttype( p_getMemberType( member_num )); 
+   return( inttype );
+}
+
+FloatType CompType::getMemberFloatType( int member_num ) const
+{
+   FloatType floatype( p_getMemberType( member_num )); 
+   return( floatype );
+}
+
+StrType CompType::getMemberStrType( int member_num ) const
+{
+   StrType strtype( p_getMemberType( member_num )); 
+   return( strtype );
+}
+
+/* old style of getMemberType - using overloads; new style above 
+   returns the appropriate datatypes but has different named functions.
+// Returns the datatype of the specified member in this compound datatype. 
+// Several overloading of getMemberType are for different datatypes
+void CompType::getMemberType( int member_num, EnumType& enumtype ) const
+{
+   p_getMemberType( member_num, enumtype ); 
+}
+
+void CompType::getMemberType( int member_num, CompType& comptype ) const
+{
+   p_getMemberType( member_num, comptype ); 
+}
+
+void CompType::getMemberType( int member_num, IntType& inttype ) const
+{
+   p_getMemberType( member_num, inttype ); 
+}
+
+void CompType::getMemberType( int member_num, FloatType& floatype ) const
+{
+   p_getMemberType( member_num, floatype ); 
+}
+
+void CompType::getMemberType( int member_num, StrType& strtype ) const
+{
+   p_getMemberType( member_num, strtype ); 
+}
+// end of overloading of getMemberType
+*/
+
+// Adds a new member to a compound datatype
+void CompType::insertMember( const string name, size_t offset, const DataType& new_member ) const
+{
+   // Convert string to C-string
+   const char* name_C;
+   name_C = name.c_str();  // name_C refers to the contents of name as a C-str
+
+   hid_t new_member_id = new_member.getId();  // get new_member id for C API
+
+   // Call C routine H5Tinsert to add the new member
+   herr_t ret_value = H5Tinsert( id, name_C, offset, new_member_id );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Adds an array member to this compound datatype.
+void CompType::insertMember( const string member_name, size_t offset, int ndims, const size_t* dim, const int* perm, const DataType& new_member ) const
+{
+   throw DataTypeIException( "Error: insertMember is no longer supported.");
+}
+
+// Recursively removes padding from within a compound datatype. 
+void CompType::pack() const
+{
+   // Calls C routine H5Tpack to remove padding
+   herr_t ret_value = H5Tpack( id );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// This destructor just invokes the base-class' destructor
+CompType::~CompType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5CompType.h b/c++/src/H5CompType.h
new file mode 100644
index 0000000..9b2c983
--- /dev/null
+++ b/c++/src/H5CompType.h
@@ -0,0 +1,84 @@
+#ifndef _H5CompType_H
+#define _H5CompType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class CompType : public DataType {
+   public:
+	// Creates a new datatype
+	CompType( size_t size ); // H5Tcreate
+
+	// Default constructor
+	CompType();
+
+	// Creates a compound datatype using an existing id
+	CompType( hid_t existing_id );
+
+	// Copy constructor - makes a copy of original object
+	CompType( const CompType& original );
+
+	// Gets the compound datatype of the specified dataset
+	CompType( const DataSet& dataset );  // H5Dget_type
+
+	// Retrieves the number of members in this compound datatype. 
+	int getNmembers() const;
+
+	// Retrieves the name of a member of this compound datatype. 
+	string getMemberName( int member_num ) const;
+
+	// Retrieves the offset of a member of this compound datatype. 
+	size_t getMemberOffset( int memb_no ) const;
+
+	// Returns the dimensionality of the specified member. 
+	int getMemberDims( int member_num, size_t* dims, int* perm ) const;
+
+	// Gets the type class of the specified member.  It provides to
+	// the user a way of knowing what type to declare.
+	H5T_class_t getMemberClass( int member_num ) const;
+
+	// Returns the generic datatype of the specified member in 
+	// this compound datatype.
+	DataType getMemberDataType( int member_num ) const;
+
+	// Returns the enumeration datatype of the specified member in 
+	// this compound datatype.
+	EnumType getMemberEnumType( int member_num ) const;
+
+	// Returns the compound datatype of the specified member in 
+	// this compound datatype.
+	CompType getMemberCompType( int member_num ) const;
+
+	// Returns the integer datatype of the specified member in 
+	// this compound datatype.
+	IntType getMemberIntType( int member_num ) const;
+
+	// Returns the floating-point datatype of the specified member in 
+	// this compound datatype.
+	FloatType getMemberFloatType( int member_num ) const;
+
+	// Returns the string datatype of the specified member in 
+	// this compound datatype.
+	StrType getMemberStrType( int member_num ) const;
+
+	// Adds a new member to this compound datatype.
+	void insertMember( const string name, size_t offset, const DataType& new_member ) const;
+
+	// Adds an array datatype member to this compound datatype.
+	void insertMember( const string name, size_t offset, int ndims, const size_t* dim, const int* perm, const DataType& new_member ) const;
+
+	// Recursively removes padding from within this compound datatype. 
+	void pack() const;
+
+	virtual ~CompType();
+
+   private:
+	// Contains common code that is used by the member functions
+	// getMemberXxxType
+	hid_t p_getMemberType( int member_num ) const; 
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Cpp.h b/c++/src/H5Cpp.h
new file mode 100644
index 0000000..6188b67
--- /dev/null
+++ b/c++/src/H5Cpp.h
@@ -0,0 +1,29 @@
+#ifndef _H5CPP_H
+#define _H5CPP_H
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5DataSpace.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5AbstractDs.h"
+#include "H5Attribute.h"
+#include "H5DataType.h"
+#include "H5DcreatProp.h"
+#include "H5DxferProp.h"
+#include "H5FaccProp.h"
+#include "H5FcreatProp.h"
+#include "H5AtomType.h"
+#include "H5PredType.h"
+#include "H5EnumType.h"
+#include "H5IntType.h"
+#include "H5FloatType.h"
+#include "H5StrType.h"
+#include "H5CompType.h"
+#include "H5DataSet.h"
+#include "H5Group.h"
+#include "H5File.h"
+#include "H5Library.h"
+#endif
diff --git a/c++/src/H5DataSet.C b/c++/src/H5DataSet.C
new file mode 100644
index 0000000..1cc66a2
--- /dev/null
+++ b/c++/src/H5DataSet.C
@@ -0,0 +1,207 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5PropList.h"
+#include "H5DxferProp.h"
+#include "H5DataType.h"
+#include "H5DcreatProp.h"
+#include "H5DataSpace.h"
+#include "H5AbstractDs.h"
+#include "H5DataSet.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+DataSet::DataSet() : AbstractDs() {}
+
+// Creates a copy of DataSet using an existing id
+DataSet::DataSet( const hid_t dataset_id ) : AbstractDs( dataset_id ) {}
+
+// Copy constructor makes a copy of the original object by using base
+// class' copy constructors
+DataSet::DataSet( const DataSet& original ) : AbstractDs( original ) {}
+
+// Gets a copy of the dataspace of this dataset
+DataSpace DataSet::getSpace() const
+{
+   // Calls C function H5Dget_space to get the id of the dataspace
+   hid_t dataspace_id = H5Dget_space( id );
+
+   // If the dataspace id is invalid, throw an exception
+   if( dataspace_id <= 0 )
+   {
+      throw DataSetIException();
+   }
+   //create dataspace object using the existing id then return the object
+   DataSpace data_space( dataspace_id );
+   return( data_space );
+}
+
+// This private member function calls the C API to get the identifier 
+// of the datatype that is used by this dataset.  It is used
+// by the various AbstractDs functions to get the specific datatype.
+hid_t DataSet::p_getType() const
+{
+   hid_t type_id = H5Dget_type( id );
+   if( type_id > 0 )
+      return( type_id );
+   else
+   {
+      throw DataSetIException();
+   }
+}
+
+// Gets the dataset creation property list
+DSetCreatPropList DataSet::getCreatePlist() const
+{
+   hid_t create_plist_id = H5Dget_create_plist( id );
+   if( create_plist_id <= 0 )
+   {
+      throw DataSetIException();
+   }
+   // create and return the DSetCreatPropList object 
+   DSetCreatPropList create_plist( create_plist_id );
+   return( create_plist );
+}
+
+// Returns the amount of storage required for a dataset.  
+hsize_t DataSet::getStorageSize() const
+{
+   hsize_t storage_size = H5Dget_storage_size( id );
+
+   if( storage_size > 0 )
+      return( storage_size );
+   else
+   {
+      throw DataSetIException();
+   }
+}
+
+// Returns the number of bytes required to store VL data.
+hsize_t DataSet::getVlenBufSize( DataType& type, DataSpace& space ) const
+{
+   //herr_t ret_value;
+   // Obtain identifiers for C API
+   //hid_t type_id = type.getId();
+   //hid_t space_id = space.getId();
+   //hsize_t size;
+
+   throw DataSetIException( "getVlenBufSize: Currently not implemented yet.");
+   //ret_value = H5Dget_vlen_buf_size( id, type_id, space_id, &size );
+   //if( ret_value >= 0 )
+   //   return( size );
+   //else
+   //{
+      //throw DataSetIException();
+   //}
+}
+
+// Reclaims VL datatype memory buffers. 
+void DataSet::vlenReclaim( DataType& type, DataSpace& space, DSetMemXferPropList& xfer_plist, void* buf ) const
+{
+   herr_t ret_value;
+   // Obtain identifiers for C API
+   hid_t type_id = type.getId();
+   hid_t space_id = space.getId();
+   hid_t xfer_plist_id = xfer_plist.getId();
+
+   ret_value = H5Dvlen_reclaim( type_id, space_id, xfer_plist_id, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Reads raw data from the specified dataset into buf, converting from 
+// file datatype and dataspace to memory datatype and dataspace. 
+void DataSet::read( void* buf, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
+{
+   // Obtain identifiers for C API
+   hid_t mem_type_id = mem_type.getId();
+   hid_t mem_space_id = mem_space.getId();
+   hid_t file_space_id = file_space.getId();
+   hid_t xfer_plist_id = xfer_plist.getId();
+
+   herr_t ret_value = H5Dread( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Writes raw data from an application buffer buffer to a dataset, 
+// converting from memory datatype and dataspace to file datatype 
+// and dataspace.
+void DataSet::write( const void* buf, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
+{
+   // Obtain identifiers for C API
+   hid_t mem_type_id = mem_type.getId();
+   hid_t mem_space_id = mem_space.getId();
+   hid_t file_space_id = file_space.getId();
+   hid_t xfer_plist_id = xfer_plist.getId();
+
+   herr_t ret_value = H5Dwrite( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Iterates over all selected elements in a dataspace. 
+int DataSet::iterateElems( void* buf, const DataType& type, const DataSpace& space, H5D_operator_t op, void* op_data )
+{
+   // Obtain identifiers for C API
+   hid_t type_id = type.getId();
+   hid_t space_id = space.getId();
+   herr_t ret_value = H5Diterate( buf, type_id, space_id, op, op_data );
+   if( ret_value >= 0 )
+      return( ret_value );
+   else  // raise exception when H5Diterate returns a negative value
+   {
+      throw DataSetIException();
+   }
+}
+
+// Extends a dataset with unlimited dimension.
+void DataSet::extend( const hsize_t* size ) const
+{
+   herr_t ret_value = H5Dextend( id, size );
+   if( ret_value < 0 )  // raise exception when H5Dextend returns a neg value
+   {
+      throw DataSetIException();
+   }
+}
+
+// This private function calls the C API H5Dclose to close this dataset.
+// Used by IdComponent::reset
+void DataSet::p_close() const
+{
+   herr_t ret_value = H5Dclose( id );
+   if( ret_value < 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+DataSet::~DataSet()
+{
+   // The dataset id will be closed properly
+   resetIdComponent( this );
+}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5DataSet.h b/c++/src/H5DataSet.h
new file mode 100644
index 0000000..8a59234
--- /dev/null
+++ b/c++/src/H5DataSet.h
@@ -0,0 +1,67 @@
+#ifndef _H5DataSet_H
+#define _H5DataSet_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class DataSet : public AbstractDs {
+
+   public:
+	// Default constructor
+	DataSet();
+
+	// Copy constructor
+	DataSet( const DataSet& original );
+
+	// Gets the dataspace of this dataset.
+	virtual DataSpace getSpace() const;
+
+	// Gets the creation property list of this dataset.
+	DSetCreatPropList getCreatePlist() const;
+
+	// Gets the storage size of this dataset.
+	hsize_t getStorageSize() const;
+
+	// - C version not yet implemented??
+	hsize_t getVlenBufSize( DataType& type, DataSpace& space ) const;
+	void vlenReclaim( DataType& type, DataSpace& space, DSetMemXferPropList& xfer_plist, void* buf ) const;
+
+	// Reads the data of this dataset and stores it in the provided buffer.
+	// The memory and file dataspaces and the transferring property list
+	// can be defaults.
+	void read( void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+
+	// Writes the buffered data to this dataset.
+	// The memory and file dataspaces and the transferring property list
+	// can be defaults.
+	void write( const void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+
+	// Iterates the selected elements in the specified dataspace - not implemented in C++ style yet
+        int iterateElems( void* buf, const DataType& type, const DataSpace& space, H5D_operator_t op, void* op_data = NULL );
+
+	// Extends the dataset with unlimited dimension.
+	void extend( const hsize_t* size ) const;
+
+	// Creates a copy of an existing DataSet using its id
+	// (used only by template functions in FGtemplates.h
+	// to return a DataSet, will not be published; Note: should use
+	// friend template function)
+	DataSet( const hid_t dataset_id );
+
+	// Used by the API to appropriately close a dataset
+	virtual void p_close() const;
+
+	virtual ~DataSet();
+
+   private:
+        // This function contains the common code that is used by
+        // getTypeClass and various API functions getXxxType 
+        // defined in AbstractDs for generic datatype and specific
+        // sub-types
+	virtual hid_t p_getType() const;
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5DataSpace.C b/c++/src/H5DataSpace.C
new file mode 100644
index 0000000..67857ee
--- /dev/null
+++ b/c++/src/H5DataSpace.C
@@ -0,0 +1,321 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5Exception.h"
+#include "H5RefCounter.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5DataSpace.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const DataSpace DataSpace::ALL( H5S_ALL );
+
+// Default constructor
+DataSpace::DataSpace() : IdComponent() {}
+
+// This constructor creates a DataSpace instance, given a dataspace type
+DataSpace::DataSpace( H5S_class_t type ) : IdComponent()
+{
+   id = H5Screate( type );
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Creates a new simple data space and opens it for access.
+DataSpace::DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims) : IdComponent()
+{
+   id = H5Screate_simple( rank, dims, maxdims );
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+/* Constructor that takes an existing dataspace id
+Description:
+	Uses an HDF5 id to create a DataSpace identifier instance.  This id can be either an existing dataspace id or a default dataspace id.  Design note: in the case of default dataspace, the identifier still has reference counter; the p_close function will take care of not to call H5Sclose on the default id.
+*/
+DataSpace::DataSpace( const hid_t space_id ) : IdComponent( space_id ) {}
+
+// Copy constructor: makes a copy of the original DataSpace instance
+DataSpace::DataSpace( const DataSpace& original ) : IdComponent( original ) {}
+
+// Makes a copy of an existing dataspace
+void DataSpace::copy( const DataSpace& like_space )
+{
+   // reset the identifier of this instance - send 'this' in so that
+   // H5Sclose can be called appropriately
+   resetIdComponent( this );
+
+   // call C routine to copy the dataspace 
+   id = H5Scopy( like_space.getId() );
+
+   // points to the same ref counter
+   ref_count = like_space.ref_count;
+
+   // increment ref counter to indicate additional references to this id
+   ref_count->increment();
+
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determines whether this dataspace is a simple dataspace.
+bool DataSpace::isSimple () const
+{
+   htri_t simple = H5Sis_simple( id );
+   if( simple > 0 )
+      return true;
+   else if( simple == 0 )
+      return false;
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Sets the offset of this simple dataspace.
+void DataSpace::offsetSimple ( const hssize_t* offset ) const
+{
+   herr_t ret_value = H5Soffset_simple( id, offset );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Retrieves dataspace dimension size and maximum size
+int DataSpace::getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims ) const
+{
+   int ndims = H5Sget_simple_extent_dims( id, dims, maxdims );
+   if( ndims < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( ndims );
+}
+
+// Determines the dimensionality of a dataspace
+int DataSpace::getSimpleExtentNdims () const
+{
+   int ndims = H5Sget_simple_extent_ndims( id );
+   if( ndims < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( ndims );
+}
+
+// Determines the number of elements in a dataspace
+hsize_t DataSpace::getSimpleExtentNpoints () const
+{
+   hsize_t num_elements = H5Sget_simple_extent_npoints( id );
+
+   // num_elements = 0 when failure occurs
+   if( num_elements > 0 )
+      return( num_elements );
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determine the current class of a dataspace
+H5S_class_t DataSpace::getSimpleExtentType () const
+{
+   H5S_class_t class_name = H5Sget_simple_extent_type( id );
+   if( class_name == H5S_NO_CLASS )
+   {
+      throw DataSpaceIException();
+   }
+   return( class_name );
+}
+
+// Copies the extent of a dataspace
+void DataSpace::extentCopy ( DataSpace& dest_space ) const
+{
+   hid_t dest_space_id = dest_space.getId();
+   herr_t ret_value = H5Sextent_copy( dest_space_id, id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Sets or resets the size of an existing dataspace
+void DataSpace::setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sset_extent_simple( id, rank, current_size, maximum_size );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Removes the extent from a dataspace
+void DataSpace::setExtentNone () const
+{
+   herr_t ret_value = H5Sset_extent_none( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determines the number of elements in a dataspace selection
+hssize_t DataSpace::getSelectNpoints () const
+{
+   hssize_t num_elements = H5Sget_select_npoints( id );
+   if( num_elements < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_elements );
+}
+
+// Get number of hyperslab blocks
+hssize_t DataSpace::getSelectHyperNblocks () const
+{
+   hssize_t num_blocks = H5Sget_select_hyper_nblocks( id );
+   if( num_blocks < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_blocks );
+}
+
+// Gets the list of hyperslab blocks currently selected
+void DataSpace::getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sget_select_hyper_blocklist( id, startblock, numblocks, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Gets the number of element points in the current selection
+hssize_t DataSpace::getSelectElemNpoints () const
+{
+   hssize_t num_points = H5Sget_select_elem_npoints( id );
+   if( num_points < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_points );
+}
+
+// Gets the list of element points currently selected
+void DataSpace::getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sget_select_elem_pointlist( id, startpoint, numpoints, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Gets the bounding box containing the current selection
+void DataSpace::getSelectBounds ( hsize_t* start, hsize_t* end ) const
+{
+   herr_t ret_value = H5Sget_select_bounds( id, start, end );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects array elements to be included in the selection for a dataspace
+void DataSpace::selectElements ( H5S_seloper_t op, const size_t num_elements, const hssize_t *coord[ ] ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sselect_elements( id, op, num_elements, coord );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects the entire dataspace
+void DataSpace::selectAll () const
+{
+   herr_t ret_value = H5Sselect_all( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+//Resets the selection region to include no elements
+void DataSpace::selectNone () const
+{
+  herr_t ret_value = H5Sselect_none( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Verifies that the selection is within the extent of the dataspace
+bool DataSpace::selectValid () const
+{
+  htri_t ret_value = H5Sselect_valid( id );
+   if( ret_value > 0 )
+      return true;
+   else if( ret_value == 0 )
+      return false;
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects a hyperslab region to add to the current selected region
+void DataSpace::selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hssize_t *start, const hsize_t *stride, const hsize_t *block ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sselect_hyperslab( id, op, start, stride, count, block );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Closes the dataspace if it is not a constant
+void DataSpace::p_close() const
+{
+   hid_t space_id = id;
+   if( space_id != H5S_ALL ) // not a constant, should call H5Sclose
+   {
+      herr_t ret_value = H5Sclose( space_id );
+      if( ret_value < 0 )
+      {
+         throw DataSpaceIException();
+      }
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+DataSpace::~DataSpace()
+{  
+   // The dataspace id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5DataSpace.h b/c++/src/H5DataSpace.h
new file mode 100644
index 0000000..ddbb29c
--- /dev/null
+++ b/c++/src/H5DataSpace.h
@@ -0,0 +1,110 @@
+#ifndef _H5DataSpace_H
+#define _H5DataSpace_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class DataSpace : public IdComponent {
+   public:
+	// Default DataSpace objects
+	static const DataSpace ALL;
+
+	// Default constructor
+	DataSpace();
+
+	// Creates a dataspace object given the space type
+	DataSpace( H5S_class_t type ); // H5Screate
+
+	// Assignement operator
+	//DataSpace& operator=( const DataSpace& rhs );
+
+	// Creates a simple dataspace
+	DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims = NULL); // H5Screate_simple
+
+	// Copy constructor: makes a copy of the original DataSpace object.
+	DataSpace( const DataSpace& original );
+
+	// Makes copy of an existing dataspace.
+	void copy( const DataSpace& like_space ); // H5Scopy
+
+	// Gets value of member id of this dataspace
+        //hid_t getId () const;
+
+	// Sets value for member id of this dataspace.
+        //void setId( hid_t new_space_id );
+
+	// Determines if this dataspace is a simple one.
+	bool isSimple () const;
+
+	// Sets the offset of this simple dataspace.
+	void offsetSimple ( const hssize_t* offset ) const;
+
+	// Retrieves dataspace dimension size and maximum size.
+	int getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims = NULL ) const;
+
+	// Gets the dimensionality of this dataspace.
+	int getSimpleExtentNdims () const;
+
+	// Gets the number of elements in this dataspace.
+	hsize_t getSimpleExtentNpoints () const;
+
+	// Gets the current class of this dataspace.
+	H5S_class_t getSimpleExtentType () const;
+
+	// Copies the extent of this dataspace.
+	void extentCopy ( DataSpace& dest_space ) const;
+
+	// Sets or resets the size of this dataspace.
+	void setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size = NULL ) const;
+
+	// Removes the extent from this dataspace.
+	void setExtentNone () const;
+
+	// Gets the number of elements in this dataspace selection.
+	hssize_t getSelectNpoints () const;
+
+	// Get number of hyperslab blocks.
+	hssize_t getSelectHyperNblocks () const;
+
+	// Gets the list of hyperslab blocks currently selected.
+	void getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const;
+
+	// Gets the number of element points in the current selection.
+	hssize_t getSelectElemNpoints () const;
+
+	// Retrieves the list of element points currently selected.
+	void getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const;
+
+	// Gets the bounding box containing the current selection.
+	void getSelectBounds ( hsize_t* start, hsize_t* end ) const;
+
+	// Selects array elements to be included in the selection for 
+	// this dataspace.
+	void selectElements ( H5S_seloper_t op, const size_t num_elements, const hssize_t *coord[ ] ) const;
+
+	// Selects the entire dataspace.
+	void selectAll () const;
+
+	// Resets the selection region to include no elements.
+	void selectNone () const;
+
+	// Verifies that the selection is within the extent of the dataspace.
+	bool selectValid () const;
+
+	// Selects a hyperslab region to add to the current selected region.
+	void selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hssize_t *start, const hsize_t *stride = NULL, const hsize_t *block = NULL ) const;
+
+	// Uses an existing dataspace identifier to make a DataSpace object
+	// or uses a default id to create a default dataspace object
+	DataSpace( const hid_t space_id );
+
+	// Used by the API to close the dataspace 
+	void p_close() const;
+
+	virtual ~DataSpace();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5DataType.C b/c++/src/H5DataType.C
new file mode 100644
index 0000000..b376f61
--- /dev/null
+++ b/c++/src/H5DataType.C
@@ -0,0 +1,341 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AtomType.h"
+#include "H5PredType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Constructor creates a copy of an existing DataType using its id.
+// 'predefined' is default to false; when a default datatype is 
+// created, this argument is set to true so H5Tclose will not be 
+// called on it later.
+DataType::DataType( const hid_t existing_id, bool predefined ) : H5Object( existing_id ), is_predtype( predefined ) {
+}
+
+// Creates a datatype given its class and size
+DataType::DataType( const H5T_class_t type_class, size_t size ) : H5Object(), is_predtype( false )
+{
+   // Call C routine to create the new datatype
+   id = H5Tcreate( type_class, size );
+   if( id <= 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Default constructor
+DataType::DataType() : H5Object(), is_predtype( false )
+{
+}
+
+// Copy constructor: makes a copy of this DataType object.
+DataType::DataType( const DataType& original ) : H5Object( original  )
+{
+   is_predtype = original.is_predtype; // copy data member from original
+}
+
+// Copies an existing datatype to this datatype object
+void DataType::copy( const DataType& like_type )
+{
+   // reset the identifier of this instance, H5Tclose will be called 
+   // if needed 
+   resetIdComponent( this );
+
+   // call C routine to copy the datatype
+   id = H5Tcopy( like_type.getId() );
+   ref_count = like_type.ref_count;
+
+   // increment ref counter to indicate additional references to this id
+   ref_count->increment();
+
+   if( id <= 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Determines whether two datatypes are the same. ???
+bool DataType::operator==(const DataType& compared_type ) const
+{
+   // Call C routine H5Tequal to determines whether two datatype 
+   // identifiers refer to the same datatype
+   htri_t ret_value = H5Tequal( id, compared_type.getId() );
+   if( ret_value > 0 )
+      return true;
+   else if( ret_value == 0 )
+      return false;
+   else
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Operates a user's function on each attribute of an object - commented
+// out because it should use the one from H5Object; need to check 
+// the parameter list???
+//int DataType::iterate( unsigned * idx, H5A_operator_t op, void *op_data )
+//{
+   // Call C routine H5Aiterate to iterate the object's attributes
+   //int ret_value = H5Aiterate( id, idx, op, op_data );
+   //if( ret_value >= 0 )
+      //return( ret_value );
+   //else
+   //{
+      //throw DataTypeIException();
+   //}
+//}
+
+// Creates a new variable-length datatype - Note: make it inheritance???
+//DataType DataType::vlenCreate( const DataType& base_type )
+//{
+   // Call C routine to create a new VL datatype
+   //hid_t type_id = H5Tvlen_create( id );
+   //if( type_id > 0 )
+      //id_obj->setId( type_id );
+   //else
+   //{
+      //throw DataTypeIException();
+   //}
+//}
+
+// Commits a transient datatype to a file, creating a new named datatype
+void DataType::commit( H5Object& loc, const string& name ) const
+{
+   commit( loc, name.c_str() );
+}
+void DataType::commit( H5Object& loc, const char* name ) const
+{
+   hid_t loc_id = loc.getId(); // get location id for C API
+
+   // Call C routine to commit the transient datatype 
+   herr_t ret_value = H5Tcommit( loc_id, name, id );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Determines whether a datatype is a named type or a transient type. 
+bool DataType::committed() const
+{
+   // Call C function to determine if a datatype is a named one
+   htri_t committed = H5Tcommitted( id );
+   if( committed > 0 )
+      return true;
+   else if( committed == 0 )
+      return false;
+   else
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Finds a conversion function.
+H5T_conv_t DataType::find( const DataType& dest, H5T_cdata_t **pcdata ) const
+{
+   // Call C routine to find the conversion function
+   H5T_conv_t func = H5Tfind( id, dest.getId(), pcdata );
+   if( func == NULL )
+   {
+      throw DataTypeIException();
+   }
+   return( func );
+}
+
+// Converts data from between specified datatypes. 
+void DataType::convert( const DataType& dest, size_t nelmts, void *buf, void *background, PropList& plist ) const
+{
+   // Get identifiers for C API
+   hid_t dest_id = dest.getId();
+   hid_t plist_id = plist.getId();
+
+   // Call C routine H5Tconvert to convert the data
+   herr_t ret_value;
+   ret_value = H5Tconvert( id, dest_id, nelmts, buf, background, plist_id );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Sets the overflow handler to a specified function. 
+void DataType::setOverflow( H5T_overflow_t func ) const
+{
+   // Call C routine H5Tset_overflow to set the overflow handler
+   herr_t ret_value = H5Tset_overflow( func );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns a pointer to the current global overflow function. 
+H5T_overflow_t DataType::getOverflow(void) const
+{
+   return( H5Tget_overflow());  // C routine
+   // NULL can be returned as well
+}
+
+// Locks a datatype. 
+void DataType::lock() const
+{
+   // Call C routine to lock the datatype
+   herr_t ret_value = H5Tlock( id );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the datatype class identifier. 
+H5T_class_t DataType::getClass() const
+{
+   H5T_class_t type_class = H5Tget_class( id );
+
+   // Return datatype class identifier if successful
+   if( type_class == H5T_NO_CLASS )
+   {
+      throw DataTypeIException();
+   }
+   return( type_class );
+}
+
+// Returns the size of a datatype. 
+size_t DataType::getSize() const
+{
+   // Call C routine to get the datatype size
+   size_t type_size = H5Tget_size( id );
+   if( type_size <= 0 ) // Is 0 valid value ???
+   {
+      throw DataTypeIException();
+   }
+   return( type_size );
+}
+
+// Returns the base datatype from which a datatype is derived. 
+// - just for DataType?
+DataType DataType::getSuper() const
+{
+   // Call C routine to get the base datatype from which the specified
+   // datatype is derived. 
+   hid_t base_type_id = H5Tget_super( id );
+
+   // If H5Tget_super returns a valid datatype id, create and return
+   // the base type, otherwise, raise exception
+   if( base_type_id > 0 )
+   {
+      DataType base_type( base_type_id );
+      return( base_type );
+   }
+   else {}
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Registers the specified conversion function. 
+void DataType::registerFunc( H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const
+{
+   registerFunc( pers, name.c_str(), dest, func );
+}
+void DataType::registerFunc( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const
+{
+   hid_t dest_id = dest.getId();  // get id of the destination datatype
+
+   // Call C routine H5Tregister to register the conversion function
+   herr_t ret_value = H5Tregister( pers, name, id, dest_id, func );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Removes a conversion function from all conversion paths. 
+void DataType::unregister( H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const
+{
+   unregister( pers, name.c_str(), dest, func );
+}
+void DataType::unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const
+{
+   hid_t dest_id = dest.getId();  // get id of the dest datatype for C API
+
+   // Call C routine H5Tunregister to remove the conversion function 
+   herr_t ret_value = H5Tunregister( pers, name, id, dest_id, func );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Tags an opaque datatype. 
+void DataType::setTag( const string& tag ) const
+{
+   setTag( tag.c_str());
+}
+void DataType::setTag( const char* tag ) const
+{
+   // Call C routine H5Tset_tag to tag an opaque datatype. 
+   herr_t ret_value = H5Tset_tag( id, tag );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Gets the tag associated with an opaque datatype. 
+string DataType::getTag() const
+{
+   char* tag_Cstr = H5Tget_tag( id );
+
+   // if the tag C-string returned is not NULL, convert it to C++ string
+   // and return it, otherwise, raise an exception
+   if( tag_Cstr != NULL )
+   {
+      string tag = string( tag_Cstr );
+      return( tag );
+   }
+   else
+   {
+      throw DataTypeIException();
+   }
+}
+
+// This private function calls the C API H5Tclose to close this datatype.
+// Used by H5Object::p_reset.
+void DataType::p_close() const
+{
+   // If this datatype is not a predefined type, call H5Tclose on it.
+   if( is_predtype == false )
+   {
+      herr_t ret_value = H5Tclose( id );
+      if( ret_value < 0 )
+      {
+         throw DataTypeIException();
+      }
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+DataType::~DataType()
+{  
+   // The datatype id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5DataType.h b/c++/src/H5DataType.h
new file mode 100644
index 0000000..0fa1965
--- /dev/null
+++ b/c++/src/H5DataType.h
@@ -0,0 +1,94 @@
+#ifndef _H5DataType_H
+#define _H5DataType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class DataType : public H5Object {
+   public:
+	// Default constructor
+	DataType();
+
+	// Creates a datatype given its class and size
+	DataType( const H5T_class_t type_class, size_t size );
+
+	// Copy constructor: makes a copy of the original object
+	DataType( const DataType& original );
+
+	// Creates a new variable-length datatype - not implemented yet
+	// Will be moved into a subclass when completed
+	//DataType vlenCreate( const DataType& base_type );
+
+	// Copies an existing datatype to this datatype object
+	void copy( const DataType& like_type );
+
+	// Returns the datatype class identifier. 
+	H5T_class_t getClass() const;
+
+	// Commits a transient datatype to a file; this datatype becomes 
+	// a named datatype which can be accessed from the location.
+	void commit( H5Object& loc, const string& name ) const;
+	void commit( H5Object& loc, const char* name ) const;
+
+	// Determines whether this datatype is a named datatype or 
+	// a transient datatype. 
+	bool committed() const;
+
+        // Finds a conversion function that can handle the conversion 
+        // this datatype to the given datatype, dest.
+	H5T_conv_t find( const DataType& dest, H5T_cdata_t **pcdata ) const;
+
+	// Converts data from between specified datatypes. 
+	void convert( const DataType& dest, size_t nelmts, void *buf, void *background, PropList& plist ) const;
+
+	// Sets the overflow handler to a specified function. 
+	void setOverflow(H5T_overflow_t func) const;
+
+	// Returns a pointer to the current global overflow function. 
+	H5T_overflow_t getOverflow(void) const;
+
+	// Determines whether two datatypes are the same. ???
+	bool operator==(const DataType& compared_type ) const;
+
+	// Locks a datatype. 
+	void lock() const;
+
+	// Returns the size of a datatype. 
+	size_t getSize() const;
+
+	// Returns the base datatype from which a datatype is derived. 
+	// Note: not quite right for specific types yet???
+	DataType getSuper() const;
+
+	// Registers a conversion function. 
+	void registerFunc(H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
+	void registerFunc(H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
+
+	// Removes a conversion function from all conversion paths. 
+	void unregister( H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
+	void unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
+
+	// Tags an opaque datatype. 
+	void setTag( const string& tag ) const;
+	void setTag( const char* tag ) const;
+
+	// Gets the tag associated with an opaque datatype. 
+	string getTag() const;
+
+	// Used by the API to appropriately close a datatype
+        void p_close() const;
+
+	// Creates a copy of an existing DataType using its id 
+	DataType( const hid_t type_id, bool predtype = false );
+
+	virtual ~DataType();
+
+   protected:
+	bool is_predtype;	// indicates a type is predefined so
+				// H5Tclose will not be called for it
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5DcreatProp.C b/c++/src/H5DcreatProp.C
new file mode 100644
index 0000000..adaa046
--- /dev/null
+++ b/c++/src/H5DcreatProp.C
@@ -0,0 +1,173 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5DcreatProp.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const DSetCreatPropList DSetCreatPropList::DEFAULT( H5P_DEFAULT );
+
+// Copy constructor: makes a copy of the original DSetCreatPropList object;
+DSetCreatPropList::DSetCreatPropList( const DSetCreatPropList& orig ) : PropList( orig ) {}
+
+// Copies a dataset creation property list using assignment statement
+DSetCreatPropList& DSetCreatPropList::operator=( const DSetCreatPropList& rhs )
+{
+   copy (rhs);
+   return( *this );
+}
+
+// Sets the size of the chunks used to store a chunked layout dataset.
+void DSetCreatPropList::setChunk( int ndims, const hsize_t* dim ) const
+{
+   herr_t ret_value = H5Pset_chunk( id, ndims, dim );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Gets the layout of the raw data storage of the data that uses this
+// property list
+H5D_layout_t DSetCreatPropList::getLayout() const
+{
+   H5D_layout_t layout = H5Pget_layout( id );
+   if( layout == H5D_LAYOUT_ERROR )
+   {
+      throw PropListIException();
+   }
+   return( layout );
+}
+
+// Retrieves the size of the chunks used to store a chunked layout dataset.
+int DSetCreatPropList::getChunk( int max_ndims, hsize_t* dim ) const
+{
+   int chunk_size = H5Pget_chunk( id, max_ndims, dim );
+   if( chunk_size < 0 )
+   {
+      throw PropListIException();
+   }
+   return( chunk_size );
+}
+
+// Sets the type of storage used store the raw data for a dataset.
+void DSetCreatPropList::setLayout(hid_t plist, H5D_layout_t layout ) const
+{
+   herr_t ret_value = H5Pset_layout( id, layout );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Sets compression method and compression level
+void DSetCreatPropList::setDeflate( int level ) const
+{
+   herr_t ret_value = H5Pset_deflate( id, level );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Sets a dataset fill value
+void DSetCreatPropList::setFillValue( DataType& fvalue_type, const void* value ) const
+{
+   herr_t ret_value = H5Pset_fill_value( id, fvalue_type.getId(), value );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Retrieves a dataset fill value
+void DSetCreatPropList::getFillValue( DataType& fvalue_type, void* value ) const
+{
+   herr_t ret_value = H5Pget_fill_value( id, fvalue_type.getId(), value );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Adds a filter to the filter pipeline
+void DSetCreatPropList::setFilter( H5Z_filter_t filter, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const
+{
+   herr_t ret_value = H5Pset_filter( id, filter, flags, cd_nelmts, cd_values );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Returns the number of filters in the pipeline 
+int DSetCreatPropList::getNfilters() const
+{
+   int num_filters = H5Pget_nfilters( id );
+   if( num_filters < 0 )
+   {
+      throw PropListIException();
+   }
+   else
+      return( num_filters );
+}
+
+// Returns information about a filter in a pipeline
+H5Z_filter_t DSetCreatPropList::getFilter( int filter_number, unsigned int& flags, size_t& cd_nelmts, unsigned int* cd_values, size_t namelen, char name[] ) const
+{
+   H5Z_filter_t filter;
+   filter = H5Pget_filter( id, filter_number, &flags, &cd_nelmts, cd_values, namelen, name );
+   if( filter == H5Z_FILTER_ERROR )
+   {
+      throw PropListIException();
+   }
+   else
+      return( filter );
+}
+
+// Adds an external file to the list of external files
+void DSetCreatPropList::setExternal( const char* name, off_t offset, hsize_t size ) const
+{
+   herr_t ret_value = H5Pset_external( id, name, offset, size );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Returns the number of external files for a dataset 
+int DSetCreatPropList::getExternalCount() const
+{
+   int num_ext_files = H5Pget_external_count( id );
+   if( num_ext_files < 0 )
+   {
+      throw PropListIException();
+   }
+   else
+      return( num_ext_files );
+}
+
+// Returns information about an external file
+void DSetCreatPropList::getExternal( int idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const
+{
+   herr_t ret_value = H5Pget_external( id, idx, name_size, name, &offset, &size );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Default destructor
+DSetCreatPropList::~DSetCreatPropList () {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5DcreatProp.h b/c++/src/H5DcreatProp.h
new file mode 100644
index 0000000..5fa67ee
--- /dev/null
+++ b/c++/src/H5DcreatProp.h
@@ -0,0 +1,73 @@
+#ifndef _H5DSCreatPropList_H
+#define _H5DSCreatPropList_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class DSetCreatPropList : public PropList {
+   public:
+	static const DSetCreatPropList DEFAULT;
+
+	// Creates a dataset creation property list
+	DSetCreatPropList() : PropList( H5P_DATASET_CREATE ) {}
+
+	// Copy constructor: creates a copy of a DSetCreatPropList object;
+	// often used by the compiler when passing by value occurs.
+	DSetCreatPropList( const DSetCreatPropList& orig );
+
+	// Copies a dataset creation property list using assignment statement
+	DSetCreatPropList& operator=( const DSetCreatPropList& rhs );
+
+	// Sets the type of storage used to store the raw data for the 
+	// dataset that uses this property list
+	void setLayout(hid_t plist, H5D_layout_t layout ) const;
+
+	// Gets the layout of the raw data storage of the data that uses this
+	// property list
+	H5D_layout_t getLayout() const;
+
+	// Sets the size of the chunks used to store a chunked layout dataset.
+	void setChunk( int ndims, const hsize_t* dim ) const;
+
+	// Retrieves the size of the chunks used to store a chunked layout dataset.
+	int getChunk( int max_ndims, hsize_t* dim ) const;
+
+	// Sets compression method and compression level
+	void setDeflate( int level ) const;
+
+	// Sets a dataset fill value
+	void setFillValue( DataType& fvalue_type, const void* value ) const;
+
+	// Retrieves a dataset fill value
+	void getFillValue( DataType& fvalue_type, void* value ) const;
+
+	// Adds a filter to the filter pipeline
+	void setFilter( H5Z_filter_t filter, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const;
+
+	// Returns the number of filters in the pipeline 
+	int getNfilters() const;
+
+	// Returns information about a filter in a pipeline
+	H5Z_filter_t getFilter( int filter_number, unsigned int& flags, size_t& cd_nelmts, unsigned int* cd_values, size_t namelen, char name[] ) const;
+
+	// Adds an external file to the list of external files
+	void setExternal( const char* name, off_t offset, hsize_t size ) const;
+
+	// Returns the number of external files for a dataset 
+	int getExternalCount() const;
+
+	// Returns information about an external file
+	void getExternal( int idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const;
+
+	// Creates a copy of an existing dataset creation property list 
+	// using the property list id
+	DSetCreatPropList( const hid_t plist_id ) : PropList( plist_id ) {}
+
+	// Default destructor
+	virtual ~DSetCreatPropList();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5DxferProp.C b/c++/src/H5DxferProp.C
new file mode 100644
index 0000000..ff96b66
--- /dev/null
+++ b/c++/src/H5DxferProp.C
@@ -0,0 +1,183 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5DxferProp.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const DSetMemXferPropList DSetMemXferPropList::DEFAULT( H5P_DEFAULT );
+
+// Creates a dataset memory and transfer property list
+DSetMemXferPropList::DSetMemXferPropList() : PropList( H5P_DATASET_XFER ) {}
+
+// Copy constructor: makes a copy of the original DSetMemXferPropList object;
+DSetMemXferPropList::DSetMemXferPropList( const DSetMemXferPropList& orig ) : PropList( orig ) {}
+
+// Copies a dataset transfer property list using assignment statement
+// Notes: can this be inherited from PropList??? and copy or operator=???
+DSetMemXferPropList& DSetMemXferPropList::operator=( const DSetMemXferPropList& rhs )
+{
+   copy (rhs);
+   return( *this );
+}
+
+// Sets type conversion and background buffers
+void DSetMemXferPropList::setBuffer( size_t size, void* tconv, void* bkg ) const
+{
+   herr_t ret_value = H5Pset_buffer( id, size, tconv, bkg );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Reads buffer settings
+size_t DSetMemXferPropList::getBuffer( void** tconv, void** bkg ) const
+{
+   size_t buffer_size = H5Pget_buffer( id, tconv, bkg );
+   if( buffer_size == 0 )
+   {
+      throw PropListIException();
+   }
+   return( buffer_size );
+}
+
+// Sets the dataset transfer property list status to TRUE or FALSE
+void DSetMemXferPropList::setPreserve( bool status ) const
+{
+   herr_t ret_value = H5Pset_preserve( id, (hbool_t) status );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Checks status of the dataset transfer property list
+bool DSetMemXferPropList::getPreserve() const
+{
+   int ret_value = H5Pget_preserve( id );
+   if( ret_value > 0 )
+      return true;
+   else if( ret_value == 0 )
+      return false;
+   else
+   {
+      throw PropListIException();
+   }
+}
+
+// Indicates whether to cache hyperslab blocks during I/O
+void DSetMemXferPropList::setHyperCache( bool cache, unsigned limit ) const
+{
+   herr_t ret_value = H5Pset_hyper_cache( id, cache, limit );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Returns information regarding the caching of hyperslab blocks during I/O
+void DSetMemXferPropList::getHyperCache( bool& cache, unsigned& limit ) const
+{
+   unsigned temp_cache;  // C routine takes hid_t, unsigned*, unsigned*
+   herr_t ret_value = H5Pget_hyper_cache( id, &temp_cache, &limit );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+   if( temp_cache > 0 )
+      cache = true;
+   else
+      cache = false;
+}
+
+// Sets B-tree split ratios for a dataset transfer property list 
+void DSetMemXferPropList::setBtreeRatios( double left, double middle, double right ) const
+{
+   herr_t ret_value = H5Pset_btree_ratios( id, left, middle, right );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Gets B-tree split ratios for a dataset transfer property list
+void DSetMemXferPropList::getBtreeRatios( double& left, double& middle, double& right ) const
+{
+   herr_t ret_value = H5Pget_btree_ratios( id, &left, &middle, &right );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Sets the memory manager for variable-length datatype allocation
+void DSetMemXferPropList::setVlenMemManager( H5MM_allocate_t alloc_func, void* alloc_info, H5MM_free_t free_func, void* free_info ) const
+{
+   herr_t ret_value = H5Pset_vlen_mem_manager( id, alloc_func, alloc_info, 
+						free_func, free_info );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// alloc_func and free_func are set to NULL, indicating that system malloc and 
+// free are to be used
+void DSetMemXferPropList::setVlenMemManager() const
+{
+   setVlenMemManager( NULL, NULL, NULL, NULL );
+   //herr_t ret_value = H5Pset_vlen_mem_manager( id, NULL, NULL, NULL, NULL );
+   //if( ret_value < 0 )
+   //{
+      //throw PropListIException();
+   //}
+}
+
+// Gets the memory manager for variable-length datatype allocation 
+void DSetMemXferPropList::getVlenMemManager( H5MM_allocate_t& alloc_func, void** alloc_info, H5MM_free_t& free_func, void** free_info ) const
+{
+   herr_t ret_value = H5Pget_vlen_mem_manager( id, &alloc_func, alloc_info, &free_func, free_info );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+/* these two functions are in parallel mode only - not supported at this time.
+// Sets the transfer mode
+void DSetMemXferPropList::setXfer( H5D_transfer_t data_xfer_mode = H5D_XFER_INDEPENDENT ) const
+{
+   herr_t ret_value = H5Pset_xfer( ... );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Gets the transfer mode
+H5D_transfer_t DSetMemXferPropList::getXfer() const
+{
+   H5D_transfer_t xfer = H5Pget_xfer( id );
+// remove when done - find out what the value is for ??
+   if( xfer == ?? )
+   {
+      throw PropListIException();
+   }
+   return( xfer );
+}
+
+*/
+
+// Default destructor
+DSetMemXferPropList::~DSetMemXferPropList() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5DxferProp.h b/c++/src/H5DxferProp.h
new file mode 100644
index 0000000..2e7f51a
--- /dev/null
+++ b/c++/src/H5DxferProp.h
@@ -0,0 +1,77 @@
+#ifndef _H5DSetMemXferPropList_H
+#define _H5DSetMemXferPropList_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class DSetMemXferPropList : public PropList {
+   public:
+	static const DSetMemXferPropList DEFAULT;
+
+	// Creates a dataset memory and transfer property list
+	DSetMemXferPropList();
+
+	// Copy constructor: creates a copy of a DSetMemXferPropList object
+	DSetMemXferPropList( const DSetMemXferPropList& orig );
+
+	// Copies a dataset memory and transfer property list using 
+	// assignment statement
+	DSetMemXferPropList& operator=( const DSetMemXferPropList& rhs );
+
+	// Sets type conversion and background buffers
+	void setBuffer( size_t size, void* tconv, void* bkg ) const;
+
+	// Reads buffer settings
+	size_t getBuffer( void** tconv, void** bkg ) const;
+
+	// Sets the dataset transfer property list status to TRUE or FALSE
+	void setPreserve( bool status ) const;
+
+	// Checks status of the dataset transfer property list
+	bool getPreserve() const;
+
+	// Indicates whether to cache hyperslab blocks during I/O
+	void setHyperCache( bool cache, unsigned limit = 0 ) const;
+
+	// Returns information regarding the caching of hyperslab blocks during I/O
+	void getHyperCache( bool& cache, unsigned& limit ) const;
+
+	// Sets B-tree split ratios for a dataset transfer property list 
+	void setBtreeRatios( double left, double middle, double right ) const;
+
+	// Gets B-tree split ratios for a dataset transfer property list
+	void getBtreeRatios( double& left, double& middle, double& right ) const;
+
+	// Sets the memory manager for variable-length datatype 
+	// allocation in H5Dread and H5Dvlen_reclaim
+	void setVlenMemManager( H5MM_allocate_t alloc, void* alloc_info, 
+				H5MM_free_t free, void* free_info ) const;
+
+	// alloc and free are set to NULL, indicating that system 
+	// malloc and free are to be used
+	void setVlenMemManager() const;
+
+	// Gets the memory manager for variable-length datatype 
+	// allocation in H5Dread and H5Tvlen_reclaim
+	void getVlenMemManager( H5MM_allocate_t& alloc, void** alloc_info, 
+				H5MM_free_t& free, void** free_info ) const;
+
+	// Sets the transfer mode - parallel mode, not currently supported
+	//void setXfer( H5D_transfer_t data_xfer_mode = H5D_XFER_INDEPENDENT ) const;
+
+	// Gets the transfer mode - parallel mode, not currently supported
+	//H5D_transfer_t getXfer() const;
+
+	// Creates a copy of an existing dataset memory and transfer 
+	// property list using the property list id
+	DSetMemXferPropList (const hid_t plist_id) : PropList( plist_id ) {}
+
+	// Default destructor
+	virtual ~DSetMemXferPropList();
+
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5EnumType.C b/c++/src/H5EnumType.C
new file mode 100644
index 0000000..303bac5
--- /dev/null
+++ b/c++/src/H5EnumType.C
@@ -0,0 +1,128 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5AbstractDs.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5DataType.h"
+#include "H5DataSet.h"
+#include "H5AtomType.h"
+#include "H5IntType.h"
+#include "H5EnumType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Creates an empty enumeration datatype based on a native signed
+// integer type.
+EnumType::EnumType( size_t size ) : DataType( H5T_ENUM, size ) {}
+
+// Default constructor
+EnumType::EnumType() : DataType() {}
+
+// Creates a enumeration datatype using an existing id
+EnumType::EnumType( const hid_t existing_id ) : DataType( existing_id ) {}
+
+// Copy constructor: makes a copy of the original EnumType object. 
+EnumType::EnumType( const EnumType& original ) : DataType( original ) {}
+
+// Gets the enum datatype of the specified dataset 
+EnumType::EnumType( const DataSet& dataset ) : DataType()
+{
+   // Calls C function H5Dget_type to get the id of the datatype
+   id = H5Dget_type( dataset.getId() );
+
+   // If the datatype id is not valid, throw an exception
+   if( id <= 0 )
+   {
+      throw DataSetIException("Getting datatype fails...");
+   }
+}
+
+// Creates a new enum datatype based on an integer datatype
+EnumType::EnumType( const IntType& data_type ) : DataType()
+{
+   // Calls C function H5Tenum_create to get the id of the datatype
+   id = H5Tenum_create( data_type.getId() );
+
+   // If the datatype id is not valid, throw an exception
+   if( id <= 0 )
+   {
+      throw DataSetIException("Creating enumeration datatype fails...");
+   }
+}
+
+// Inserts a new member to this enumeration datatype.
+void EnumType::insert( const string& name, void *value ) const
+{
+    insert( name.c_str(), value );
+}
+void EnumType::insert( const char* name, void *value ) const
+{
+   // Calls C routine H5Tenum_insert to insert the new enum datatype member. 
+   herr_t ret_value = H5Tenum_insert( id, name, value );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Returns the symbol name corresponding to a specified member of an enumeration datatype. 
+string EnumType::nameOf( void *value, size_t size ) const
+{
+   char* name_C = new char[size+1];  // temporary C-string for C API
+
+   // Calls C routine H5Tenum_nameof to get the name of the specified enum type
+   herr_t ret_value = H5Tenum_nameof( id, value, name_C, size );
+
+   // If H5Tenum_nameof returns a negative value, raise an exception,
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+   // otherwise, create the string to hold the datatype name and return it
+   string name = string( name_C );
+   delete name_C;
+   return( name );
+}
+
+// Retrieves the value corresponding to a member of an enumeration 
+// datatype, given the member's name. 
+void EnumType::valueOf( const string& name, void *value ) const
+{
+    valueOf( name.c_str(), value );
+}
+void EnumType::valueOf( const char* name, void *value ) const
+{
+   // Calls C routine H5Tenum_valueof to get the enum datatype value
+   herr_t ret_value = H5Tenum_valueof( id, name, value );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the value of a member in this enumeration datatype, given the 
+// member's index.
+void EnumType::getMemberValue( int memb_no, void *value ) const
+{
+   // Call C routine H5Tget_member_value to get the datatype member's value
+   hid_t ret_value = H5Tget_member_value( id, memb_no, value );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Default destructor
+EnumType::~EnumType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5EnumType.h b/c++/src/H5EnumType.h
new file mode 100644
index 0000000..92583aa
--- /dev/null
+++ b/c++/src/H5EnumType.h
@@ -0,0 +1,51 @@
+#ifndef _H5EnumType_H
+#define _H5EnumType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class EnumType : public DataType {
+
+   public:
+	// Creates an empty enumeration datatype based on a native signed 
+	// integer type, whose size is given by size.
+	EnumType( size_t size );
+
+	// Default constructor
+	EnumType();
+
+	// Creates an enumeration datatype using an existing id
+	EnumType( hid_t existing_id );
+
+	// Copy constructor: makes a copy of the original EnumType object.
+	EnumType( const EnumType& original );
+
+	// Gets the enum datatype of the specified dataset
+	EnumType( const DataSet& dataset );  // H5Dget_type
+
+	// Creates a new enum datatype based on an integer datatype
+	EnumType( const IntType& data_type );  // H5Tenum_create
+
+	// Inserts a new member to this enumeration type. 
+	void insert( const string& name, void *value ) const;
+	void insert( const char* name, void *value ) const;
+
+	// Returns the symbol name corresponding to a specified member 
+	// of this enumeration datatype. 
+	string nameOf( void *value, size_t size ) const;
+
+	// Returns the value corresponding to a specified member of this 
+	// enumeration datatype. 
+	void valueOf( const string& name, void *value ) const;
+	void valueOf( const char* name, void *value ) const;
+
+	// Returns the value of an enumeration datatype member
+	void getMemberValue( int memb_no, void *value ) const;
+
+	virtual ~EnumType();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Exception.C b/c++/src/H5Exception.C
new file mode 100644
index 0000000..6302fe5
--- /dev/null
+++ b/c++/src/H5Exception.C
@@ -0,0 +1,188 @@
+#ifdef OLD_HEADER_FILENAME
+#include <iostream.h>
+#else
+#include <iostream>
+#endif
+
+#include "H5Include.h"
+#include <string>
+
+// Added this line for CC to work at this time.  Will remove it when 
+// the problem is fixed. BMR - 10/30/00
+
+#include "H5Exception.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+Exception::Exception() : detailMessage("") {}
+
+Exception::Exception( const char* message) : detailMessage(static_cast<string>(message)) {}
+
+Exception::Exception( const string& message ) : detailMessage( message ) {}
+
+// copy constructor
+Exception::Exception( const Exception& orig )
+{
+   detailMessage = orig.detailMessage;
+}
+
+// Returns the character string that describes an error specified by
+// a major error number.
+string Exception::getMajorString( H5E_major_t major_num ) const
+{
+   // calls the C API routine to get the major string - Note: in the
+   // failure case, the string "Invalid major error number" will be returned.
+   string major_str( H5Eget_major( major_num ));
+   return( major_str );
+}
+
+// Returns the character string that describes an error specified by
+// a minor error number.
+string Exception::getMinorString( H5E_minor_t minor_num ) const
+{
+   // calls the C API routine to get the minor string - Note: in the
+   // failure case, the string "Invalid minor error number" will be returned.
+   string minor_str( H5Eget_minor( minor_num ));
+   return( minor_str );
+}
+
+// Turns on the automatic error printing.
+void Exception::setAutoPrint( H5E_auto_t func, void* client_data ) const
+{
+   // calls the C API routine H5Eset_auto to set the auto printing to
+   // the specified function.
+   herr_t ret_value = H5Eset_auto( func, client_data );
+   if( ret_value < 0 )
+      throw Exception( "setAutoPrint: H5Eset_auto fails" );
+}
+
+// Turns off the automatic error printing.
+void Exception::dontPrint()
+{
+   // calls the C API routine H5Eset_auto with NULL parameters to turn
+   // off the automatic error printing.
+   herr_t ret_value = H5Eset_auto( NULL, NULL );
+   if( ret_value < 0 )
+      throw Exception( "dontPrint: H5Eset_auto fails" );
+}
+
+// Retrieves the current settings for the automatic error stack traversal
+// function and its data.
+void Exception::getAutoPrint( H5E_auto_t& func, void** client_data ) const
+{
+   // calls the C API routine H5Eget_auto to get the current setting of
+   // the automatic error printing 
+   herr_t ret_value = H5Eget_auto( &func, client_data );
+   if( ret_value < 0 )
+      throw Exception( "getAutoPrint: H5Eget_auto fails" );
+}
+
+// Clears the error stack for the current thread.
+void Exception::clearErrorStack() const
+{
+   // calls the C API routine H5Eclear to clear the error stack
+   herr_t ret_value = H5Eclear();
+   if( ret_value < 0 )
+      throw Exception( "clearErrorStack: H5Eclear fails" );
+}
+
+// Walks the error stack for the current thread, calling the specified function.
+void Exception::walkErrorStack( H5E_direction_t direction, H5E_walk_t func, void* client_data ) const
+{
+   // calls the C API routine H5Ewalk to walk the error stack
+   herr_t ret_value = H5Ewalk( direction, func, client_data );
+   if( ret_value < 0 )
+      throw Exception( "walkErrorStack: H5Ewalk fails" );
+}
+
+// Default error stack traversal callback function that prints error
+// messages to the specified output stream.
+void Exception::walkDefErrorStack( int n, H5E_error_t& err_desc, void* client_data ) const
+{
+   // calls the C API routine H5Ewalk_cb to walk the error stack
+   herr_t ret_value = H5Ewalk_cb( n, &err_desc, client_data );
+   if( ret_value < 0 )
+      throw Exception( "walkDefErrorStack: H5Ewalk_cb fails" );
+}
+
+// Returns the detailed message set at the time the exception is thrown
+string Exception::getDetailMesg() const
+{
+   return( detailMessage );
+}
+
+// Prints the error stack in a default manner.
+void Exception::printError( FILE* stream ) const
+{
+   herr_t ret_value = H5Eprint( NULL ); // print to stderr
+   if( ret_value < 0 )
+      throw Exception( "printError: H5Eprint fails" );
+}
+
+FileIException::FileIException():Exception(){};
+FileIException::FileIException( string message ): 
+Exception( message ){};
+
+GroupIException::GroupIException():Exception(){};
+GroupIException::GroupIException( string message ): 
+Exception( message ){};
+
+ObjectHeaderException::ObjectHeaderException():Exception(){};
+ObjectHeaderException::ObjectHeaderException( string message ): Exception( message ) {};
+
+DataSpaceIException::DataSpaceIException():Exception(){};
+DataSpaceIException::DataSpaceIException( string message ): Exception( message ) {};
+
+DataTypeIException::DataTypeIException():Exception(){};
+DataTypeIException::DataTypeIException( string message ): Exception( message ) {};
+
+PropListIException::PropListIException():Exception(){};
+PropListIException::PropListIException( string message ): Exception( message ) {};
+
+DataSetIException::DataSetIException():Exception(){};
+DataSetIException::DataSetIException( string message ): Exception( message ) {};
+
+AttributeIException::AttributeIException():Exception(){};
+AttributeIException::AttributeIException( string message ): Exception( message ) {};
+
+FunctionArgumentException::FunctionArgumentException():Exception(){};
+FunctionArgumentException::FunctionArgumentException( string message ): Exception( message ) {};
+
+ReferenceException::ReferenceException():Exception(){};
+ReferenceException::ReferenceException( string message ):
+Exception( message ) {};
+
+DataStorageException::DataStorageException():Exception(){};
+DataStorageException::DataStorageException( string message ):
+Exception( message ) {};
+
+LibraryIException::LibraryIException():Exception(){};
+LibraryIException::LibraryIException( string message ):
+Exception( message ) {};
+
+IdComponentException::IdComponentException(): Exception() {};
+IdComponentException::IdComponentException( string message ): Exception( message ) {};
+
+// The following are from Java API but not done here:
+// AtomException, BtreeException, DataFiltersException, 
+// ExternalFileListException, FunctionEntryExitException, 
+// HeapException, InternalErrorException, LowLevelIOException, 
+// MetaDataCacheException, ResourceUnavailableException, 
+// SymbolTableException 
+
+File_GroupException::File_GroupException()
+{
+   // for now, do nothing
+}
+
+File_GroupException::File_GroupException( string message )
+{
+   // for now, do nothing
+}
+
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5Exception.h b/c++/src/H5Exception.h
new file mode 100644
index 0000000..69ecf42
--- /dev/null
+++ b/c++/src/H5Exception.h
@@ -0,0 +1,163 @@
+#ifndef _H5Exception_H
+#define _H5Exception_H
+
+#include <string>
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+using namespace std;
+#endif
+
+class Exception {
+   public:
+	// Creates an exception with no message
+	Exception();
+
+	// Creates an exception with a detailed message
+	Exception( const string& message );
+
+	Exception( const char* message);
+
+	// copy constructor
+	Exception( const Exception& orig );
+
+	// Returns the character string that describes an error specified by
+	// a major error number.
+	string getMajorString( H5E_major_t major_num ) const;
+
+	// Returns the character string that describes an error specified by
+	// a minor error number.
+	string getMinorString( H5E_minor_t minor_num ) const;
+
+	// Returns the detailed message set at the time the exception is thrown
+	string getDetailMesg() const;
+
+	// Turns on the automatic error printing.
+	void setAutoPrint( H5E_auto_t func, 
+				void* client_data ) const;
+
+	// Turns off the automatic error printing.
+	static void dontPrint();
+
+	// Retrieves the current settings for the automatic error stack 
+	// traversal function and its data.
+	void getAutoPrint( H5E_auto_t& func, 
+				void** client_data ) const;
+
+	// Clears the error stack for the current thread.
+	void clearErrorStack() const;
+
+	// Walks the error stack for the current thread, calling the 
+	// specified function.
+	void walkErrorStack( H5E_direction_t direction, 
+				H5E_walk_t func, void* client_data ) const;
+
+	// Default error stack traversal callback function that prints 
+	// error messages to the specified output stream.
+	void walkDefErrorStack( int n, H5E_error_t& err_desc,
+				void* client_data ) const;
+
+	// Prints the error stack in a default manner.
+	//void printError() const;
+	void printError( FILE* stream = NULL ) const;
+
+   private:
+	string detailMessage;
+};
+
+// This exception is privately used in Group and H5File only
+class File_GroupException {
+   public:
+	File_GroupException();
+	File_GroupException( string message );
+};
+
+class FileIException : public Exception {
+   public:
+	FileIException();
+	FileIException( string message );
+};
+
+class GroupIException : public Exception {
+   public:
+	GroupIException();
+	GroupIException( string message );
+};
+
+class ObjectHeaderException : public Exception {
+   public:
+	ObjectHeaderException();
+	ObjectHeaderException( string message );
+};
+
+class DataSpaceIException : public Exception {
+   public:
+	DataSpaceIException();
+	DataSpaceIException( string message );
+};
+
+class DataTypeIException : public Exception {
+   public:
+	DataTypeIException();
+	DataTypeIException( string message );
+};
+
+class PropListIException : public Exception {
+   public:
+	PropListIException();
+	PropListIException( string message );
+};
+
+class DataSetIException : public Exception {
+   public:
+	DataSetIException();
+	DataSetIException( string message );
+};
+
+class AttributeIException : public Exception {
+   public:
+	AttributeIException();
+	AttributeIException( string message );
+};
+
+class FunctionArgumentException : public Exception {
+   public:
+	FunctionArgumentException();
+	FunctionArgumentException( string message );
+};
+
+class ReferenceException : public Exception {
+   public:
+	ReferenceException();
+	ReferenceException( string message );
+};
+
+class DataStorageException : public Exception {
+   public:
+	DataStorageException();
+	DataStorageException( string message );
+};
+
+class LibraryIException : public Exception {
+   public:
+	LibraryIException();
+	LibraryIException( string message );
+};
+
+class IdComponentException : public Exception {
+   public:
+	IdComponentException();
+	IdComponentException( string message );
+};
+
+// The following are from Java API but not done here:
+// AtomException, BtreeException, DataFiltersException, 
+// ExternalFilelistException, FunctionEntryExitException, 
+// HeapException, InternalErrorException, LowLevelIOException, 
+// MetaDataCacheException, ResourceUnavailableException, 
+// SymbolTableException 
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+
+#endif // _H5Exception_H
diff --git a/c++/src/H5FaccProp.C b/c++/src/H5FaccProp.C
new file mode 100644
index 0000000..a59173d
--- /dev/null
+++ b/c++/src/H5FaccProp.C
@@ -0,0 +1,244 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5FaccProp.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const FileAccPropList FileAccPropList::DEFAULT( H5P_DEFAULT );
+
+// Creates a file access property list
+FileAccPropList::FileAccPropList() : PropList( H5P_FILE_ACCESS ) {}
+
+// Copy constructor: makes a copy of the original FileAccPropList object;
+FileAccPropList::FileAccPropList( const FileAccPropList& orig ) : PropList( orig ) {}
+
+// Copies a file access property list using assignment statement
+// Notes: can this be inherited from PropList??? and copy or operator=???
+FileAccPropList& FileAccPropList::operator=( const FileAccPropList& rhs )
+{
+   copy (rhs);
+   return( *this );
+}
+
+/* commented out for 1.3.x, only in 1.2.x
+void FileAccPropList::setStdio() const
+{
+   herr_t ret_value = H5Pset_stdio( id );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+bool FileAccPropList::getStdio() const
+{
+   herr_t ret_value = H5Pget_stdio( id );
+   if( ret_value < 0 )
+      return( false );
+   else
+      return( true );
+}
+
+H5F_driver_t FileAccPropList::getDriver() const
+{
+   H5F_driver_t driver = H5Pget_driver( id );
+   if( driver == H5F_LOW_ERROR )
+   {
+      throw PropListIException();
+   }
+   return( driver );
+}
+
+void FileAccPropList::setSec2() const
+{
+   herr_t ret_value = H5Pset_sec2( id );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+bool FileAccPropList::getSec2() const
+{
+   herr_t ret_value = H5Pget_sec2( id );
+   if( ret_value < 0 )
+      return( false );
+   else
+      return( true );
+}
+
+void FileAccPropList::setCore( size_t increment ) const
+{
+   herr_t ret_value = H5Pset_core( id, increment );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+bool FileAccPropList::getCore( size_t& increment) const
+{
+   herr_t ret_value = H5Pget_core( id, &increment );
+   if( ret_value < 0 )
+      return( false );
+   else
+      return( true );
+}
+
+void FileAccPropList::setFamily( hsize_t memb_size, const FileAccPropList& memb_plist ) const
+{
+   herr_t ret_value = H5Pset_family( id, memb_size, memb_plist.getId() );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+//Note: working on this return value here.  added copy constructor
+//that uses PropList copy const. but din't work
+// Determines whether the file access property list is set to the family
+// driver then retrieves the family member's property list and returns
+// true or false
+bool FileAccPropList::getFamily( hsize_t& memb_size, FileAccPropList& memb_plist ) const
+{
+   hid_t memb_plist_id;
+   herr_t ret_value = H5Pget_family( id, &memb_size, &memb_plist_id );
+   if( ret_value < 0 )
+   {
+      memb_plist.setId( 0 );
+      return( false );
+   }
+   else
+   {
+      memb_plist.setId( memb_plist_id );
+      return( true );
+   }
+}
+
+void FileAccPropList::setSplit( FileAccPropList& meta_plist, FileAccPropList& raw_plist, const char* meta_ext, const char* raw_ext ) const
+{
+   hid_t meta_pid = meta_plist.getId();
+   hid_t raw_pid = raw_plist.getId();
+   herr_t ret_value = H5Pset_split( id, meta_ext, meta_pid, raw_ext, raw_pid );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileAccPropList::setSplit( FileAccPropList& meta_plist, FileAccPropList& raw_plist, const string& meta_ext, const string& raw_ext ) const
+{
+   setSplit( meta_plist, raw_plist, meta_ext.c_str(), raw_ext.c_str() );
+}
+
+void FileAccPropList::getSplit( size_t meta_ext_size, string& meta_ext, FileAccPropList& meta_plist, size_t raw_ext_size, string& raw_ext, FileAccPropList& raw_plist ) const
+{
+   hid_t meta_plist_id, raw_plist_id;	// meta-data and raw-data plist ids
+   char* meta_ext_C = new char[meta_ext_size];	// meta-data extension in C
+   char* raw_ext_C = new char[raw_ext_size];	// raw-data extension in C
+   herr_t ret_value = H5Pget_split( id, meta_ext_size, meta_ext_C, 
+		&meta_plist_id, raw_ext_size, raw_ext_C, &raw_plist_id );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+   meta_plist.setId( meta_plist_id );
+   raw_plist.setId( raw_plist_id );
+   raw_ext = string( raw_ext_C );
+   meta_ext = string( raw_ext_C );
+   delete [] raw_ext_C;
+   delete [] meta_ext_C;
+}
+*/
+
+void FileAccPropList::setAlignment( hsize_t threshold, hsize_t alignment ) const
+{
+   herr_t ret_value = H5Pset_alignment( id, threshold, alignment );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileAccPropList::getAlignment( hsize_t& threshold, hsize_t& alignment ) const
+{
+   herr_t ret_value = H5Pget_alignment( id, &threshold, &alignment );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+/* MPI_Comm and MPI_Info not declared in serial mode so leave these
+routines out until C++ API needs to deal with parallel
+void FileAccPropList::setMpi( MPI_Comm comm, MPI_Info info ) const
+{
+   herr_t ret_value = H5Pset_mpi( id, comm, info );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileAccPropList::getMpi( MPI_Comm& comm, MPI_Info& info ) const
+{
+   herr_t ret_value = H5Pget_mpi( id, &comm, &info );
+   if( ret_value < 0 )
+      return( false );
+   else
+      return( true );
+}
+*/
+
+void FileAccPropList::setCache( int mdc_nelmts, int rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const
+{
+   herr_t ret_value = H5Pset_cache( id, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0 );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileAccPropList::getCache( int& mdc_nelmts, int& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const
+{
+   herr_t ret_value = H5Pget_cache( id, &mdc_nelmts, &rdcc_nelmts, &rdcc_nbytes, &rdcc_w0 );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileAccPropList::setGcReferences( unsigned gc_ref ) const
+{
+   herr_t ret_value = H5Pset_gc_references( id, gc_ref );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+unsigned FileAccPropList::getGcReferences() const
+{
+   unsigned gc_ref;
+
+   // the name of this routine will be changed to H5Pget_gc_references???
+   herr_t ret_value = H5Pget_gc_references( id, &gc_ref );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+   return( gc_ref );
+}
+
+FileAccPropList::~FileAccPropList() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5FaccProp.h b/c++/src/H5FaccProp.h
new file mode 100644
index 0000000..e632fab
--- /dev/null
+++ b/c++/src/H5FaccProp.h
@@ -0,0 +1,106 @@
+#ifndef _H5FileAccPropList_H
+#define _H5FileAccPropList_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// class for file access properties
+class FileAccPropList : public PropList {
+   public:
+	static const FileAccPropList DEFAULT;
+
+	// Creates a file access property list.
+	FileAccPropList();
+
+	// Copy constructor: creates a copy of a FileAccPropList object
+	FileAccPropList( const FileAccPropList& orig );
+
+	// Copies a file access property list using assignment statement.
+	FileAccPropList& operator=( const FileAccPropList& rhs );
+
+	// Sets the low level file driver to use the functions 
+	// declared in the stdio.h
+	// void setStdio() const;
+
+	// Determines whether the file access property list is set to the 
+	// stdio driver.
+	// bool getStdio() const;
+
+	// Sets alignment properties of this file access property list
+	void setAlignment( hsize_t threshold = 1, hsize_t alignment = 1 ) const;
+
+	// Retrieves the current settings for alignment properties from
+	// this file access property list.
+	void getAlignment( hsize_t& threshold, hsize_t& alignment ) const;
+
+	/* MPI stuff not working in serial mode
+	//void setMpi( MPI_Comm comm, MPI_Info info ) const;
+	//void getMpi( MPI_Comm& comm, MPI_Info& info ) const;
+	*/
+
+	// Returns a low-level file driver identifier.
+	// H5F_driver_t getDriver() const;
+
+	// Sets the low-level file driver to use the declared functions.
+	// void setSec2() const;
+
+	// Determines whether this file access property list is set to the 
+	// sec2 driver.
+	// bool getSec2() const;
+
+	// Sets the low-level file driver to use malloc() and free().
+	// void setCore( size_t increment ) const;
+
+	// Determines whether this file access property list is set to the 
+	// core driver and retrieves the increment.
+	// bool getCore( size_t& increment ) const;
+
+	// Sets this file access properties list to the family driver.
+	// void setFamily( hsize_t memb_size, const FileAccPropList& memb_plist ) const;
+
+	// Determines whether this file access property list is set to the 
+	// family driver and retrieves the member's file access property list.
+	// bool getFamily( hsize_t& memb_size, FileAccPropList& memb_plist ) const;
+
+	// Sets the meta data cache and raw data chunk cache parameters.
+	void setCache( int mdc_nelmts, int rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const;
+
+	// Retrieves maximum sizes of data caches and the preemption 
+	// policy value.
+	void getCache( int& mdc_nelmts, int& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const;
+
+	// Sets the low-level driver to split meta data from raw data.
+	// void setSplit( FileAccPropList& meta_plist, FileAccPropList& raw_plist, 
+	     // const char* meta_ext = ".meta", const char* raw_ext = ".raw" ) const;
+
+	// void setSplit( FileAccPropList& meta_plist, FileAccPropList& raw_plist, 
+	     // const string& meta_ext, const string& raw_ext ) const;
+
+	// Determines whether this file access property list is set to the 
+	// split driver and retrieves the meta-data and raw-data property lists.
+	// void getSplit( size_t meta_ext_size, string& meta_ext, FileAccPropList& 
+	     // meta_plist, size_t raw_ext_size, string& raw_ext, FileAccPropList& 
+	     // raw_plist ) const;
+
+	// Proposal: 2 separate functions
+	//FileAccPropList getMetaPlist( size_t meta_ext_size, char* meta_ext );
+	//FileAccPropList getRawPlist( size_t raw_ext_size, char* raw_ext );
+
+	// Sets garbage collecting references flag.
+	void setGcReferences( unsigned gc_ref = 0 ) const;
+
+	// Returns garbage collecting references setting.
+	unsigned getGcReferences() const;
+
+	// Creates a copy of an existing file access property list
+	// using the property list id
+	FileAccPropList (const hid_t plist_id) : PropList( plist_id ) {}
+
+	// Default destructor
+	virtual ~FileAccPropList();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5FcreatProp.C b/c++/src/H5FcreatProp.C
new file mode 100644
index 0000000..41ec360
--- /dev/null
+++ b/c++/src/H5FcreatProp.C
@@ -0,0 +1,120 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5FcreatProp.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const FileCreatPropList FileCreatPropList::DEFAULT( H5P_DEFAULT );
+
+// Creates a file create property list
+FileCreatPropList::FileCreatPropList() : PropList( H5P_FILE_CREATE ) {}
+
+// Copy constructor: makes a copy of the original FileCreatPropList object;
+FileCreatPropList::FileCreatPropList( const FileCreatPropList& orig ) : PropList( orig ) {}
+
+// Copies a file create property list using assignment statement
+// Notes: can this be inherited from PropList??? and copy or operator=???
+FileCreatPropList& FileCreatPropList::operator=( const FileCreatPropList& rhs )
+{
+   copy (rhs);
+   return( *this );
+}
+
+void FileCreatPropList::getVersion( 
+			int& boot, int& freelist, int& stab, int& shhdr ) const
+{
+   herr_t ret_value = H5Pget_version( id, &boot, &freelist, &stab, &shhdr );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileCreatPropList::setUserblock( hsize_t size ) const
+{
+   herr_t ret_value = H5Pset_userblock( id, size);
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+hsize_t FileCreatPropList::getUserblock() const
+{
+   hsize_t userblock_size;
+   herr_t ret_value = H5Pget_userblock( id, &userblock_size );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+   return( userblock_size );
+}
+
+void FileCreatPropList::setSizes( size_t sizeof_addr, size_t sizeof_size ) const
+{
+   herr_t ret_value = H5Pset_sizes( id, sizeof_addr, sizeof_size );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileCreatPropList::getSizes( size_t& sizeof_addr, size_t& sizeof_size ) const
+{
+   herr_t ret_value = H5Pget_sizes( id, &sizeof_addr, &sizeof_size );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileCreatPropList::setSymk( int ik, int lk ) const
+{
+   herr_t ret_value = H5Pset_sym_k( id, ik, lk );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileCreatPropList::getSymk( int& ik, int& lk ) const
+{
+   herr_t ret_value = H5Pget_sym_k( id, &ik, &lk );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+void FileCreatPropList::setIstorek( int ik ) const
+{
+   herr_t ret_value = H5Pset_istore_k( id, ik );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+}
+int FileCreatPropList::getIstorek() const
+{
+   int ik;
+   herr_t ret_value = H5Pget_istore_k( id, &ik );
+   if( ret_value < 0 )
+   {
+      throw PropListIException();
+   }
+   return( ik );
+}
+
+// Default destructor
+FileCreatPropList::~FileCreatPropList() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5FcreatProp.h b/c++/src/H5FcreatProp.h
new file mode 100644
index 0000000..f40553f
--- /dev/null
+++ b/c++/src/H5FcreatProp.h
@@ -0,0 +1,62 @@
+#ifndef _H5FileCreatPropList_H
+#define _H5FileCreatPropList_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// class for file access properties
+class FileCreatPropList : public PropList {
+   public:
+	static const FileCreatPropList DEFAULT;
+	
+	// Creates a file create property list.
+	FileCreatPropList();
+
+	// Copy constructor: creates a copy of a FileCreatPropList object
+	FileCreatPropList( const FileCreatPropList& orig );
+
+	// Copies a file creation property list using assignment statement
+	FileCreatPropList& operator=( const FileCreatPropList& rhs );
+
+	// Retrieves version information for various parts of a file.
+	void getVersion( int& boot, int& freelist, int& stab, int& shhdr ) const;
+
+	// Sets the userblock size field of a file creation property list.
+	void setUserblock( hsize_t size ) const;
+
+	// Gets the size of a user block in this file creation property list.
+	hsize_t getUserblock() const;
+
+	// Sets file size-of addresses and sizes.
+	void setSizes( size_t sizeof_addr = 4, size_t sizeof_size = 4 ) const;
+
+	// Retrieves the size-of address and size quantities stored in a 
+	// file according to this file creation property list.
+	void getSizes( size_t& sizeof_addr, size_t& sizeof_size ) const;
+
+	// Sets the size of parameters used to control the symbol table nodes.
+	void setSymk( int int_nodes_k, int leaf_nodes_k ) const;
+
+	// Retrieves the size of the symbol table B-tree 1/2 rank and the
+	// symbol table leaf node 1/2 size.
+	void getSymk( int& int_nodes_k, int& leaf_nodes_k ) const;
+
+	// Sets the size of parameter used to control the B-trees for
+	// indexing chunked datasets.
+	void setIstorek( int ik ) const;
+
+	// Returns the 1/2 rank of an indexed storage B-tree.
+	int getIstorek() const;
+
+	// Creates a copy of an existing file create property list
+	// using the property list id
+	FileCreatPropList (const hid_t plist_id) : PropList( plist_id ) {}
+
+	// Default destructor
+	virtual ~FileCreatPropList();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5File.C b/c++/src/H5File.C
new file mode 100644
index 0000000..1ccea96
--- /dev/null
+++ b/c++/src/H5File.C
@@ -0,0 +1,474 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5FaccProp.h"
+#include "H5FcreatProp.h"
+#include "H5DxferProp.h"
+#include "H5DcreatProp.h"
+#include "H5Group.h"
+#include "H5AbstractDs.h"
+#include "H5DataSpace.h"
+#include "H5DataSet.h"
+#include "H5File.h"
+#include "H5Alltypes.h"
+#include "H5CommonFG.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Creates or opens an HDF5 file depending on the parameter flags.
+H5File::H5File( const string& name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist ) : IdComponent()
+{
+   getFile( name.c_str(), flags, create_plist, access_plist );
+}
+
+H5File::H5File( const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist ) : IdComponent()
+{
+   getFile( name, flags, create_plist, access_plist );
+}
+
+// This function is private and contains common code between the 
+// constructors taking a string or a char*
+void H5File::getFile( const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist )
+{
+   // These bits only set for creation, so if any of them are set,
+   // create the file.
+   if( flags & (H5F_ACC_EXCL|H5F_ACC_TRUNC|H5F_ACC_DEBUG ))
+   {
+      hid_t create_plist_id = create_plist.getId();
+      hid_t access_plist_id = access_plist.getId();
+      id = H5Fcreate( name, flags, create_plist_id, access_plist_id );
+   }
+   // Open the file if none of the bits above are set.
+   else
+   {
+      // use create_plist for access plist because of the default argument
+      hid_t access_plist_id = create_plist.getId();
+      id = H5Fopen( name, flags, access_plist_id );
+   }
+
+   if( id <= 0 )  // throw an exception when open/create fail
+   {
+      throw FileIException();
+   }
+}
+
+// Copy constructor: makes a copy of the original H5File object.
+H5File::H5File( const H5File& original ) : IdComponent( original ) {}
+
+// Determines whether a file specified by its name in HDF5 format
+bool H5File::isHdf5(const string& name ) 
+{
+   return( isHdf5( name.c_str()) );
+}
+bool H5File::isHdf5(const char* name ) 
+{
+   // Calls C routine H5Fis_hdf5 to determine whether the file is in 
+   // HDF5 format.  It returns positive value, 0, or negative value
+   htri_t ret_value = H5Fis_hdf5( name );
+   if( ret_value > 0 )
+      return true;
+   else if( ret_value == 0 )
+      return false;
+   else // Raise exception when H5Fis_hdf5 returns a negative value 
+   {
+      throw FileIException();
+   }
+}
+
+// Reopens this file
+void H5File::reopen()
+{
+   // reset the identifier of this H5File - send 'this' in so that
+   // H5Fclose can be called appropriately
+   resetIdComponent( this );
+
+   // call C routine to reopen the file - Note: not sure about this
+   // does id need to be closed later?  which id to be the parameter?
+   id = H5Freopen( id );
+   if( id <= 0 ) // Raise exception when H5Freopen returns a neg value
+   {
+      throw FileIException();
+   }
+}
+
+// Creates a new group in this file using the template function provided
+// in FGtemplates.h  
+Group H5File::createGroup( const string& name, size_t size_hint ) const
+{
+   return( createGroup( name.c_str(), size_hint ));
+}
+
+Group H5File::createGroup( const char* name, size_t size_hint ) const
+{
+   try {
+      Group group = createGroupT( id, name, size_hint );
+      return( group );
+   }
+   catch( File_GroupException error )
+   {
+      throw FileIException();
+   }
+}
+
+// Opens an existing group in this file using the template function provided
+// in FGtemplates.h  
+Group H5File::openGroup( const string& name ) const
+{
+   return( openGroup( name.c_str() ));
+}
+
+Group H5File::openGroup( const char* name ) const
+{
+   try {
+      Group group = openGroupT( id, name );
+      return( group );
+   }
+   catch( File_GroupException error )
+   {
+      throw FileIException();
+   }
+}
+
+// Creates a dataset in this file using the template function
+// provided in FGtemplates.h  
+DataSet H5File::createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist ) const
+{
+   return( createDataSet( name.c_str(), data_type, data_space, create_plist ));
+}
+
+DataSet H5File::createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist ) const
+{
+   try {
+      DataSet dataset = createDataSetT( id, name, data_type, data_space, create_plist );
+      return( dataset );
+   }
+   catch( File_GroupException error )
+   {
+      throw FileIException();
+   }
+}
+
+// Opens an existing dataset in this file using the template function
+// provided in FGtemplates.h  
+DataSet H5File::openDataSet( const string& name ) const
+{
+   return( openDataSet( name.c_str() ));
+}
+
+DataSet H5File::openDataSet( const char* name ) const
+{
+   try {
+      DataSet dataset = openDataSetT( id, name );
+      return( dataset );
+   }
+   catch( File_GroupException error )
+   {
+      throw FileIException();
+   }
+}
+
+// This private member function calls the C API H5Topen to open the
+// named datatype in this file, and returns the datatype's identifier.  
+// The function is used by the functions openXxxType's below for 
+// opening the sub-types
+hid_t H5File::p_openDataType( const char* name ) const
+{
+   // Call C function H5Topen to open the named datatype in this group,
+   // giving the group id
+   hid_t datatype_id = H5Topen( id, name );
+
+   // If the datatype id is valid, return it, otherwise, throw an exception.
+   if( datatype_id > 0 )
+      return( datatype_id );
+   else
+   {
+      throw FileIException();
+   }
+}
+
+//
+// The following member functions use the private function
+// p_openDataType to open a named datatype in this group
+//
+
+// Opens the named generic datatype in this group.
+DataType H5File::openDataType( const string& name ) const
+{
+   return( openDataType( name.c_str()) );
+}
+DataType H5File::openDataType( const char* name ) const
+{
+   DataType data_type( p_openDataType( name ));
+   return( data_type );
+}
+
+// Opens the named enumeration datatype in this group.
+EnumType H5File::openEnumType( const string& name ) const
+{
+   return( openEnumType( name.c_str()) );
+}
+EnumType H5File::openEnumType( const char* name ) const
+{
+   EnumType enum_type( p_openDataType( name ));
+   return( enum_type );
+}
+
+// Opens the named compound datatype in this group.
+CompType H5File::openCompType( const string& name ) const
+{
+   return( openCompType( name.c_str()) );
+}
+CompType H5File::openCompType( const char* name ) const
+{
+   CompType comp_type( p_openDataType( name ));
+   return( comp_type );
+}
+
+// Opens the named integer datatype in this group.
+IntType H5File::openIntType( const string& name ) const
+{
+   return( openIntType( name.c_str()) );
+}
+IntType H5File::openIntType( const char* name ) const
+{ 
+   IntType int_type( p_openDataType( name ));
+   return( int_type );
+}
+
+// Opens the named floating-point datatype in this group.
+FloatType H5File::openFloatType( const string& name ) const
+{
+   return( openFloatType( name.c_str()) );
+}
+FloatType H5File::openFloatType( const char* name ) const
+{
+   FloatType float_type( p_openDataType( name ));
+   return( float_type );
+}
+
+// Opens the named string datatype of this group
+StrType H5File::openStrType( const string& name ) const
+{
+   return( openStrType( name.c_str()) );
+}
+StrType H5File::openStrType( const char* name ) const
+{
+   StrType str_type( p_openDataType( name ));
+   return( str_type );
+}
+
+// Returns the creation property list of this file
+FileCreatPropList H5File::getCreatePlist() const
+{
+   hid_t create_plist_id = H5Fget_create_plist( id );
+
+   // if H5Fget_create_plist returns a valid id, create and return
+   // the FileCreatPropList object for this property list
+   if( create_plist_id > 0 )
+   {
+      FileCreatPropList create_plist( create_plist_id );
+      return( create_plist );
+   }
+   else
+   {
+      throw FileIException();
+   }
+}
+
+// Returns the access property list of this file
+FileAccPropList H5File::getAccessPlist() const
+{
+   hid_t access_plist_id = H5Fget_access_plist( id );
+
+   // if H5Fget_access_plist returns a valid id, create and return
+   // the FileAccPropList object for this property list
+   if( access_plist_id > 0 )
+   {
+      FileAccPropList access_plist( access_plist_id );
+      return access_plist;
+   }
+   else // Raise an exception
+   {
+      throw FileIException();
+   }
+}
+
+// Creates a link of the specified type from new_name to current_name;
+// both names are interpreted relative to this file
+void H5File::link( H5G_link_t link_type, const string& curr_name, const string& new_name ) const
+{
+   link( link_type, curr_name.c_str(), new_name.c_str() );
+}
+
+void H5File::link( H5G_link_t link_type, const char* curr_name, const char* new_name ) const
+{
+   try {
+      linkT( id, link_type, curr_name, new_name );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Removes the specified name from this file.
+void H5File::unlink( const string& name ) const
+{
+   unlink( name.c_str());
+}
+
+void H5File::unlink( const char* name ) const
+{
+   try {
+      unlinkT( id, name );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Renames an object from this file.
+void H5File::move( const string& src, const string& dst ) const
+{
+   move( src.c_str(), dst.c_str());
+}
+
+void H5File::move( const char* src, const char* dst ) const
+{
+   try {
+      moveT( id, src, dst );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Returns information about an object
+void H5File::getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf ) const
+{
+   getObjinfo( name, follow_link, statbuf );
+}
+
+void H5File::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const
+{
+   try {
+      getObjinfoT( id, name, follow_link, statbuf );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Returns the name of the object that the symbolic link points to.
+string H5File::getLinkval( const string& name, size_t size ) const
+{
+   return( getLinkval( name.c_str(), size ));
+}
+
+string H5File::getLinkval( const char* name, size_t size ) const
+{
+   try {
+      string value = getLinkvalT( id, name, size );
+      return( value );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Sets comment for specified object.
+void H5File::setComment( const string& name, const string& comment ) const
+{
+   setComment( name.c_str(), comment.c_str());
+}
+
+void H5File::setComment( const char* name, const char* comment ) const
+{
+   try {
+      setCommentT( id, name, comment );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Retrieves comment for specified object
+string H5File::getComment( const string& name, size_t bufsize ) const
+{
+   return( getComment( name.c_str(), bufsize ));
+}
+
+string H5File::getComment( const char* name, size_t bufsize ) const
+{
+   try {
+      string comment = getCommentT( id, name, bufsize );
+      return( comment );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Mounts the file 'child' onto this file
+void H5File::mount( const string& name, H5File& child, PropList& mount_plist ) const
+{
+   mount( name.c_str(), child, mount_plist );
+}
+
+void H5File::mount( const char* name, H5File& child, PropList& mount_plist ) const
+{
+   try {
+      mountT( id, name, child.getId(), mount_plist );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Unmounts the file named 'name' from this parent file
+void H5File::unmount( const string& name ) const
+{
+   unmount( name.c_str() );
+}
+
+void H5File::unmount( const char* name ) const
+{
+   try {
+      unmountT( id, name );
+   }
+   catch( File_GroupException error ) {
+      throw FileIException();
+   }
+}
+
+// Calls the C API H5Fclose to close this file.  Used by IdComponent::reset
+void H5File::p_close() const
+{
+   herr_t ret_value = H5Fclose( id );
+   if( ret_value < 0 )
+   {
+      throw FileIException();
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+H5File::~H5File() 
+{  
+   // The HDF5 file id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5File.h b/c++/src/H5File.h
new file mode 100644
index 0000000..782a90d
--- /dev/null
+++ b/c++/src/H5File.h
@@ -0,0 +1,132 @@
+#ifndef _H5File_H
+#define _H5File_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class H5File : public IdComponent {
+   public:
+	// copy constructor: makes a copy of the original H5File object.
+	H5File(const H5File& original );
+
+	// Creates or opens an HDF5 file.
+	H5File( const string& name, unsigned int flags,
+	   const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT,
+	   const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
+	H5File( const char* name, unsigned int flags,
+	   const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT,
+	   const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
+
+	// Sets and gets H5File's data member
+	//void setId( hid_t new_file_id );
+	//hid_t getId() const;
+
+	// Creates a new group in this file
+	Group createGroup( const string& name, size_t size_hint = 0 ) const;
+	Group createGroup( const char* name, size_t size_hint = 0 ) const;
+
+	// Opens an existing group in this file
+	Group openGroup( const string& name ) const;
+	Group openGroup( const char* name ) const;
+
+	// Determines if a file, specified by its name, is in HDF5 format
+	static bool isHdf5(const string& name );
+	static bool isHdf5(const char* name );
+
+	// Reopens this file
+	void reopen();
+
+	// Creates a new dataset in this file
+	DataSet createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
+	DataSet createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
+
+	// Opens a existing dataset in this file
+	DataSet openDataSet( const string& name ) const;
+	DataSet openDataSet( const char* name ) const;
+
+	// Opens a generic named datatype in this file
+	DataType openDataType( const string& name ) const;
+	DataType openDataType( const char* name ) const;
+
+	// Opens a named enumeration datatype in this file
+	EnumType openEnumType( const string& name ) const;
+	EnumType openEnumType( const char* name ) const;
+
+	// Opens a named compound datatype in this file
+	CompType openCompType( const string& name ) const;
+	CompType openCompType( const char* name ) const;
+
+	// Opens a named integer datatype in this file
+	IntType openIntType( const string& name ) const;
+	IntType openIntType( const char* name ) const;
+
+	// Opens a named floating-point datatype in this file
+	FloatType openFloatType( const string& name ) const;
+	FloatType openFloatType( const char* name ) const;
+
+	// Opens a named string datatype in this file
+	StrType openStrType( const string& name ) const;
+	StrType openStrType( const char* name ) const;
+
+	// Gets the creation property list of this file
+	FileCreatPropList getCreatePlist() const;
+
+	// Gets the access property list of this file
+	FileAccPropList getAccessPlist() const;
+
+	// Creates a link from new_name to current_name in this file
+	void link( H5G_link_t link_type, const string& curr_name, const string& new_name ) const;
+	void link( H5G_link_t link_type, const char* curr_name, const char* new_name ) const;
+
+	// Removes a name linked to this file
+	void unlink( const string& name ) const;
+	void unlink( const char* name ) const;
+
+	// Renames an object within this file
+	void move( const string& src, const string& dst ) const;
+	void move( const char* src, const char* dst ) const;
+
+	// Retrieves information about an object given its name and link
+	void getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
+	void getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
+
+	// Returns the name of the object that the symbolic link 'name'
+	// points to
+	string getLinkval( const string& name, size_t size ) const;
+	string getLinkval( const char* name, size_t size ) const;
+
+	// Sets the comment for an object specified by its name
+	void setComment( const string& name, const string& comment ) const;
+	void setComment( const char* name, const char* comment ) const;
+
+	// Gets the comment of an object specified by its name
+	string getComment( const string& name, size_t bufsize ) const;
+	string getComment( const char* name, size_t bufsize ) const;
+
+	// Mounts a file, specified by its name, to this file
+	void mount( const string& name, H5File& child, PropList& plist ) const;
+	void mount( const char* name, H5File& child, PropList& plist ) const;
+
+	// Unmounts a file, specified by its name, from this file
+	void unmount( const string& name ) const;
+	void unmount( const char* name ) const;
+
+	// Used by the API to appropriately close a file
+	void p_close() const;
+
+	virtual ~H5File();
+
+   private:
+	// Common code for member functions openXxxType - templates, maybe???
+	hid_t p_openDataType( const char* name ) const;
+
+	// This function is private and contains common code between the
+	// constructors taking a string or a char*
+	void getFile( const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist );
+
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5FloatType.C b/c++/src/H5FloatType.C
new file mode 100644
index 0000000..34275f8
--- /dev/null
+++ b/c++/src/H5FloatType.C
@@ -0,0 +1,153 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AbstractDs.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5AtomType.h"
+#include "H5FloatType.h"
+#include "H5DataSet.h"
+#include "H5PredType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+FloatType::FloatType() {}
+
+// Creates a floating-point type using a predefined type
+FloatType::FloatType( const PredType& pred_type ) : AtomType()
+{
+   // use DataType::copy to make a copy of this predefined type
+   copy( pred_type );
+}
+
+// Creates a floating-point datatype using an existing id
+FloatType::FloatType( const hid_t existing_id ) : AtomType( existing_id ) {}
+
+// Copy constructor: makes a copy of the original FloatType object
+FloatType::FloatType( const FloatType&  original ) : AtomType( original ){}
+
+// Gets the floating-point datatype of the specified dataset - will reimplement
+FloatType::FloatType( const DataSet& dataset ) : AtomType()
+{
+   // Calls C function H5Dget_type to get the id of the datatype
+   id = H5Dget_type( dataset.getId() );
+
+   if( id <= 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Retrieves floating point datatype bit field information. 
+void FloatType::getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mpos, size_t& msize ) const
+{
+   herr_t ret_value = H5Tget_fields( id, &spos, &epos, &esize, &mpos, &msize );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Sets locations and sizes of floating point bit fields. 
+void FloatType::setFields( size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize ) const
+{
+   herr_t ret_value = H5Tset_fields( id, spos, epos, esize, mpos, msize );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the exponent bias of a floating-point type. 
+size_t FloatType::getEbias() const
+{
+   size_t ebias = H5Tget_ebias( id );
+   // Returns the bias if successful
+   if( ebias == 0 )
+   {
+      throw DataTypeIException();
+   }
+   return( ebias );
+}
+
+// Sets the exponent bias of a floating-point type. 
+void FloatType::setEbias( size_t ebias ) const
+{
+   herr_t ret_value = H5Tset_ebias( id, ebias );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves mantissa normalization of a floating-point datatype. 
+H5T_norm_t FloatType::getNorm( string& norm_string ) const
+{
+   H5T_norm_t norm = H5Tget_norm( id );  // C routine
+   // Returns a valid normalization type if successful
+   if( norm == H5T_NORM_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   if( norm == H5T_NORM_IMPLIED )
+      norm_string = "H5T_NORM_IMPLIED (0)";
+   else if( norm == H5T_NORM_MSBSET )
+      norm_string = "H5T_NORM_MSBSET (1)";
+   else if( norm == H5T_NORM_NONE )
+      norm_string = "H5T_NORM_NONE (2)";
+   return( norm );
+}
+
+// Sets the mantissa normalization of a floating-point datatype. 
+void FloatType::setNorm( H5T_norm_t norm ) const
+{
+   herr_t ret_value = H5Tset_norm( id, norm );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the internal padding type for unused bits in floating-point datatypes. 
+H5T_pad_t FloatType::getInpad( string& pad_string ) const
+{
+   H5T_pad_t pad_type = H5Tget_inpad( id );
+   // Returns a valid padding type if successful
+   if( pad_type == H5T_PAD_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   if( pad_type == H5T_PAD_ZERO )
+      pad_string = "H5T_PAD_ZERO (0)";
+   else if( pad_type == H5T_PAD_ONE )
+      pad_string = "H5T_PAD_ONE (1)";
+   else if( pad_type == H5T_PAD_BACKGROUND )
+      pad_string = "H5T_PAD_BACKGROUD (2)";
+   return( pad_type );
+}
+
+// Fills unused internal floating point bits. 
+void FloatType::setInpad( H5T_pad_t inpad ) const
+{
+   herr_t ret_value = H5Tset_inpad( id, inpad );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Default destructor
+FloatType::~FloatType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5FloatType.h b/c++/src/H5FloatType.h
new file mode 100644
index 0000000..cc9efec
--- /dev/null
+++ b/c++/src/H5FloatType.h
@@ -0,0 +1,54 @@
+#ifndef _H5FloatType_H
+#define _H5FloatType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class FloatType : public AtomType {
+   public:
+	// default constructor
+	FloatType();
+
+	// Creates a floating-point datatype using an existing id
+	FloatType( hid_t existing_id );
+
+        // Creates a floating-point type using a predefined type
+        FloatType( const PredType& pred_type );
+
+	// Copy constructor: makes a copy of the original FloatType object.
+	FloatType( const FloatType& original );
+
+	// Gets the floating-point datatype of the specified dataset        
+	FloatType( const DataSet& dataset );
+
+	// Retrieves floating point datatype bit field information. 
+	void getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mpos, size_t& msize ) const;
+
+	// Sets locations and sizes of floating point bit fields. 
+	void setFields( size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize ) const;
+
+	// Retrieves the exponent bias of a floating-point type. 
+	size_t getEbias() const;
+
+	// Sets the exponent bias of a floating-point type. 
+	void setEbias( size_t ebias ) const;
+
+	// Retrieves mantissa normalization of a floating-point datatype. 
+	H5T_norm_t getNorm( string& norm_string ) const;
+
+	// Sets the mantissa normalization of a floating-point datatype. 
+	void setNorm( H5T_norm_t norm ) const;
+
+	// Retrieves the internal padding type for unused bits in floating-point datatypes. 
+	H5T_pad_t getInpad( string& pad_string ) const;
+	
+	// Fills unused internal floating point bits. 
+	void setInpad( H5T_pad_t inpad ) const;
+
+	virtual ~FloatType();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Group.C b/c++/src/H5Group.C
new file mode 100644
index 0000000..c765e37
--- /dev/null
+++ b/c++/src/H5Group.C
@@ -0,0 +1,382 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5AbstractDs.h"
+#include "H5FaccProp.h"
+#include "H5FcreatProp.h"
+#include "H5DcreatProp.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5DataSet.h"
+#include "H5CommonFG.h"
+#include "H5Group.h"
+#include "H5File.h"
+#include "H5Alltypes.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+Group::Group() : H5Object() {}
+
+// Copy constructor: makes a copy of the original Group object 
+Group::Group( const Group& original ) : H5Object( original ) {}
+
+// Creates a new group in this group using the common function
+// provided in FGtemplates.h.
+Group Group::createGroup( const string& name, size_t size_hint )
+{
+   return( createGroup( name.c_str(), size_hint ));
+}
+Group Group::createGroup( const char* name, size_t size_hint )
+{
+   try {
+      Group group = createGroupT( id, name, size_hint );
+      return( group );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Creates a copy of an existing Group using its id
+Group::Group( const hid_t group_id ) : H5Object( group_id ) {};
+
+// Opens an existing group in this group using the common function
+// provided in FGtemplates.h.
+Group Group::openGroup( const string& name )
+{
+   return( openGroup( name.c_str() ));
+}
+Group Group::openGroup( const char* name )
+{
+   try {
+      Group group = openGroupT( id, name );
+      return( group );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Creates a dataset in this group using the common function
+// provided in FGtemplates.h  
+DataSet Group::createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist )
+{
+   return( createDataSet( name.c_str(), data_type, data_space, create_plist ));
+}
+DataSet Group::createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist )
+{
+   try {
+      DataSet dataset = createDataSetT( id, name, data_type, data_space, create_plist );
+      return( dataset );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Opens a dataset in this group using the common function
+// provided in FGtemplates.h  
+DataSet Group::openDataSet( const string& name )
+{
+   return( openDataSet( name.c_str() ));
+}
+DataSet Group::openDataSet( const char* name )
+{
+   try {
+      DataSet dataset = openDataSetT( id, name );
+      return( dataset );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// This private member function calls the C API H5Topen to open the 
+// named datatype and returns the datatype's identifier.  The function 
+// is used by the functions openXxxType's below for opening the sub-types
+hid_t Group::p_openDataType( const char* name ) const
+{ 
+   // Call C function H5Topen to open the named datatype in this group,
+   // giving the group id 
+   hid_t datatype_id = H5Topen( id, name );
+   
+   // If the datatype id is valid, return it, otherwise, throw an exception.
+   if( datatype_id > 0 ) 
+      return( datatype_id );
+   else
+   { 
+      throw GroupIException();
+   }  
+}  
+
+//
+// The following member functions use the private function
+// p_openDataType to open a named datatype in this group
+//
+
+// Opens the named generic datatype in this group.
+DataType Group::openDataType( const string& name ) const
+{
+   return( openDataType( name.c_str()) );
+}
+DataType Group::openDataType( const char* name ) const
+{
+   DataType data_type( p_openDataType( name ));
+   return( data_type );
+}
+
+// Opens the named enumeration datatype in this group.
+EnumType Group::openEnumType( const string& name ) const
+{
+   return( openEnumType( name.c_str()) );
+}  
+EnumType Group::openEnumType( const char* name ) const
+{
+   EnumType enum_type( p_openDataType( name ));
+   return( enum_type );
+}  
+
+// Opens the named compound datatype in this group.
+CompType Group::openCompType( const string& name ) const
+{
+   return( openCompType( name.c_str()) );
+}
+CompType Group::openCompType( const char* name ) const
+{
+   CompType comp_type( p_openDataType( name ));
+   return( comp_type );
+}
+
+// Opens the named integer datatype in this group.
+IntType Group::openIntType( const string& name ) const
+{  
+   return( openIntType( name.c_str()) );
+}
+IntType Group::openIntType( const char* name ) const
+{  
+   IntType int_type( p_openDataType( name ));
+   return( int_type );
+}
+
+// Opens the named floating-point datatype in this group.
+FloatType Group::openFloatType( const string& name ) const
+{  
+   return( openFloatType( name.c_str()) );
+}
+FloatType Group::openFloatType( const char* name ) const
+{  
+   FloatType float_type( p_openDataType( name ));
+   return( float_type );
+}
+
+// Opens the named string datatype of this group
+StrType Group::openStrType( const string& name ) const
+{
+   return( openStrType( name.c_str()) );
+}
+StrType Group::openStrType( const char* name ) const
+{
+   StrType str_type( p_openDataType( name ));
+   return( str_type );
+}
+
+// Iterates a user's function over the entries of a group.
+int Group::iterateElems( const string& name, int *idx, H5G_iterate_t op , void *op_data )
+{
+   return( iterateElems( name.c_str(), idx, op, op_data ));
+}
+int Group::iterateElems( const char* name, int *idx, H5G_iterate_t op , void *op_data )
+{
+   int ret_value = H5Giterate( id, name, idx, op, op_data );
+   if( ret_value >= 0 )
+      return( ret_value );
+   else  // raise exception when H5Aiterate returns a negative value
+   {
+      throw GroupIException();
+   }
+}
+
+// Creates a link of the specified type from new_name to current_name;
+// both names are interpreted relative to this group.
+void Group::link( H5G_link_t link_type, const string& curr_name, const string& new_name )
+{
+   link( link_type, curr_name.c_str(), new_name.c_str() );
+}
+void Group::link( H5G_link_t link_type, const char* curr_name, const char* new_name )
+{
+   try {
+      linkT( id, link_type, curr_name, new_name );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Removes the specified name from this group.
+void Group::unlink( const string& name )
+{
+   unlink( name.c_str() );
+}
+void Group::unlink( const char* name )
+{
+   try {
+      unlinkT( id, name );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Renames an object from this group.
+void Group::move( const string& src, const string& dst )
+{
+   move( src.c_str(), dst.c_str() );
+}
+void Group::move( const char* src, const char* dst )
+{
+   try {
+      moveT( id, src, dst );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Retrieves information about an object.
+void Group::getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf )
+{
+   getObjinfo( name.c_str(), follow_link, statbuf );
+}
+void Group::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf )
+{
+   try {
+      getObjinfoT( id, name, follow_link, statbuf );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Returns the name of the object that the symbolic link points to.
+string Group::getLinkval( const string& name, size_t size )
+{
+   return( getLinkval( name.c_str(), size ));
+}
+string Group::getLinkval( const char* name, size_t size )
+{
+   try {
+      string value = getLinkvalT( id, name, size );
+      return( value );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Sets comment for an object specified by its name.
+void Group::setComment( const string& name, const string& comment )
+{
+   setComment( name.c_str(), comment );
+}
+void Group::setComment( const char* name, const char* comment )
+{
+   try {
+      setCommentT( id, name, comment );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Retrieves the comment of an object specified by its name
+string Group::getComment( const string& name, size_t bufsize )
+{
+   return( getComment( name.c_str(), bufsize ));
+}
+string Group::getComment( const char* name, size_t bufsize )
+{
+   try {
+      string comment = getCommentT( id, name, bufsize );
+      return( comment );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Mounts the file 'child' onto this group.
+void Group::mount( const string& name, H5File& child, PropList& plist )
+{
+   mount( name.c_str(), child, plist );
+}
+void Group::mount( const char* name, H5File& child, PropList& plist )
+{
+   try {
+      mountT( id, name, child.getId(), plist );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Unmounts the file named 'name' from this parent group.
+void Group::unmount( const string& name )
+{
+   unmount( name.c_str() );
+}
+void Group::unmount( const char* name )
+{
+   try {
+      unmountT( id, name );
+   }
+   catch( File_GroupException error )
+   {
+      throw GroupIException();
+   }
+}
+
+// Calls the C API H5Gclose to close this group.  Used by IdComponent::reset
+void Group::p_close() const
+{
+   herr_t ret_value = H5Gclose( id );
+   if( ret_value < 0 )
+   {
+      throw GroupIException();
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+Group::~Group()
+{  
+   // The group id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5Group.h b/c++/src/H5Group.h
new file mode 100644
index 0000000..6246aa4
--- /dev/null
+++ b/c++/src/H5Group.h
@@ -0,0 +1,115 @@
+#ifndef _H5Group_H
+#define _H5Group_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class Group : public H5Object {
+   public:
+	// default constructor
+	Group();
+
+	// Copy constructor: makes a copy of the original object
+	Group( const Group& original );
+
+	// Creates a group in this group
+	Group createGroup( const string& name, size_t size_hint = 0 );
+	Group createGroup( const char* name, size_t size_hint = 0 );
+
+	// Opens an existing group in this group 
+	Group openGroup( const string& name );
+	Group openGroup( const char* name );
+
+	// Creates a dataset in this group
+	DataSet createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT );
+	DataSet createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT );
+
+	// Opens a dataset in this group
+	DataSet openDataSet( const string& name );
+	DataSet openDataSet( const char* name );
+
+	// Opens a generic named datatype in this group.
+	DataType openDataType( const string& name ) const;
+	DataType openDataType( const char* name ) const;
+
+	// Opens a named enumeration datatype in this group.
+	EnumType openEnumType( const string& name ) const;
+	EnumType openEnumType( const char* name ) const;
+
+	// Opens a named compound datatype in this group.
+	CompType openCompType( const string& name ) const;
+	CompType openCompType( const char* name ) const;
+
+	// Opens a named integer datatype in this group.
+	IntType openIntType( const string& name ) const;
+	IntType openIntType( const char* name ) const;
+
+	// Opens a named floating-point datatype in this group.
+	FloatType openFloatType( const string& name ) const;
+	FloatType openFloatType( const char* name ) const;
+
+	// Opens a named string datatype in this group.
+	StrType openStrType( const string& name ) const;
+	StrType openStrType( const char* name ) const;
+
+	// Creates a link from new_name to current_name in this group.
+	void link( H5G_link_t link_type, const string& curr_name, const string& new_name );
+	void link( H5G_link_t link_type, const char* curr_name, const char* new_name );
+
+	// Removes a name linked to this group.
+	void unlink( const string& name );
+	void unlink( const char* name );
+
+	// Iterates over the elements of this group - not implemented in 
+	// C++ style yet
+	int iterateElems( const string& name, int *idx, H5G_iterate_t op, void *op_data );
+	int iterateElems( const char* name, int *idx, H5G_iterate_t op, void *op_data );
+
+	// Renames an object within this group.
+	void move( const string& src, const string& dst );
+	void move( const char* src, const char* dst );
+
+	// Retrieves information about the named object.
+	void getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf );
+	void getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf );
+
+	// Returns the name of the object that the symbolic link points to.
+	string getLinkval( const string& name, size_t size );
+	string getLinkval( const char* name, size_t size );
+
+	// Sets comment for an object specified by its name.
+	void setComment( const string& name, const string& comment );
+	void setComment( const char* name, const char* comment );
+
+	// Gets the comment of an object specified by its name.
+	string getComment( const string& name, size_t bufsize );
+	string getComment( const char* name, size_t bufsize );
+
+	// Mounts the file 'child' onto this group.
+	void mount( const string& name, H5File& child, PropList& plist);
+	void mount( const char* name, H5File& child, PropList& plist);
+
+	// Unmounts the file named 'name' from this parent group.
+	void unmount( const string& name );
+	void unmount( const char* name );
+
+	// Used by the API to appropriately close a group
+	void p_close() const;
+
+	virtual ~Group();
+
+        // Creates a copy of an existing Group using its id
+        // (used only by template functions in FGtemplates.h
+	// to return a Group; will not be published; maybe, use friend???)
+        Group( const hid_t group_id );
+
+   private:
+        // Common code for member functions openXxxType - templates, maybe???
+        hid_t p_openDataType( const char* name ) const;
+
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5IdComponent.C b/c++/src/H5IdComponent.C
new file mode 100644
index 0000000..2b7bff8
--- /dev/null
+++ b/c++/src/H5IdComponent.C
@@ -0,0 +1,136 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5Library.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor - private
+IdComponent::IdComponent() : id( 0 )
+{
+   // starts counting object references
+   ref_count = new RefCounter;
+}
+
+// Constructor that takes an HDF5 object id.  It creates an instance
+// of IdComponent to hold the HDF5 id
+IdComponent::IdComponent( hid_t h5_id ) : id( h5_id )
+{
+   // starts counting object references
+   ref_count = new RefCounter;
+}
+
+// Copy constructor: makes a copy of the original object
+IdComponent::IdComponent( const IdComponent& original )
+{
+   id = original.id;
+   ref_count = original.ref_count; // points to the same ref counter
+   ref_count->increment(); // increment number of references to this id
+}
+
+// Increment reference counter
+void IdComponent::incRefCount() { ref_count->increment(); }
+
+// Decrement reference counter
+void IdComponent::decRefCount() { ref_count->decrement(); }
+
+// Get the reference counter to this identifier
+int IdComponent::getCounter() { return( ref_count->getCounter()); }
+
+// Decrements the reference counter then determines if there are no more
+// reference to this object
+bool IdComponent::noReference()
+{
+   if( ref_count->getCounter() > 0 )
+      ref_count->decrement();
+   return( ref_count->getCounter() == 0 ? true:false );
+}
+
+/* Assignment operator.
+   Description:
+   Reset the identifier of this object so that the HDF5 id can be properly
+   closed.  Copy the new identifier to this object, then increment the 
+   reference counter of the identifier to indicate that another object 
+   is referencing the identifier.
+*/
+IdComponent& IdComponent::operator=( const IdComponent& rhs )
+{
+   // reset the identifier of this object - resetIdComponent will call the 
+   // appropriate H5xclose to close the id
+   resetIdComponent( this );
+
+   // copy the data members from the rhs object
+   id = rhs.id;
+   ref_count = rhs.ref_count; // points to the same ref counter
+
+   // increment the reference counter
+   ref_count->increment();
+
+   return( *this );
+}
+
+/* Sets the identifier of this object to a new value
+   Description:
+        Reset the current identifier of this object so that the HDF5
+        id can be appropriately closed.  If only this object references
+        its identifier, its reference counter will be deleted.  A new 
+        reference counter is created for the new HDF5 object id.
+*/
+void IdComponent::setId( hid_t new_id )
+{
+   // reset the identifier of this object, call appropriate H5Xclose
+   resetIdComponent( this );
+
+   id = new_id;
+
+   // starts counting object references
+   ref_count = new RefCounter;
+}
+
+// Gets the id of this object 
+hid_t IdComponent::getId () const
+{
+   return( id );
+}
+
+// Reset this object by deleting its RefCounter
+void IdComponent::reset ()
+{
+   delete ref_count;
+}
+
+// Default destructor
+IdComponent::~IdComponent() {
+
+/* uncomment this block when decide to use dontAtExit or fix the atexit/
+   global destructor problem - BMR 11/14/00
+
+   if( id == NOTATEXIT )
+   {
+      // Call H5Library::close to clean up - temporary solution to avoid the
+      // trouble of atexit/global destructors
+      try {
+         if( H5Library::need_cleanup == true )
+         {
+            H5Library::close();
+            H5Library::need_cleanup = false; // reset the boolean just in case
+         }
+      }
+      // catch failure caused by the H5Library operations
+      catch( LibraryIException error )
+      {
+         error.printError();
+      }
+   }
+*/
+}
+
+#ifndef H5_NO_NAMESPACE
+}
+#endif
diff --git a/c++/src/H5IdComponent.h b/c++/src/H5IdComponent.h
new file mode 100644
index 0000000..0ac9996
--- /dev/null
+++ b/c++/src/H5IdComponent.h
@@ -0,0 +1,95 @@
+#ifndef _IdComponent_H
+#define _IdComponent_H
+
+// IdComponent provides a mechanism to handle
+// reference counting for an identifier of any HDF5 object.
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class IdComponent {
+   public:
+	// Parent classes must reset the current IdComponent copy
+	// before setting new id to control reference count
+	void setId( hid_t new_id );
+
+	// Pure virtual function so appropriate close function can
+	// be called by subclasses' for the corresponding object
+	virtual void p_close() const = 0;
+
+	// Creates an object to hold an HDF5 identifier
+	IdComponent( hid_t h5_id );
+
+	// Copy constructor: makes copy of the original IdComponent object.
+	IdComponent( const IdComponent& original );
+
+	// Gets the value of IdComponent's data member
+	hid_t getId () const;
+
+	// Increment reference counter
+	void incRefCount();
+
+	// Decrement reference counter
+	void decRefCount();
+
+	// Get the reference counter to this identifier
+	int getCounter();
+
+	// Decrements the reference counter then determines if there are no more
+	// reference to this object
+	bool noReference();
+
+	// Resets this IdComponent instance
+	//template <class Type>
+	//void reset( Type* parent );
+	void reset();
+	void resetId();
+
+	// Destructor
+	virtual ~IdComponent();
+
+   protected:
+	hid_t id;	// HDF5 object id
+	RefCounter* ref_count; // used to keep track of the
+	                              // number of copies of an object
+
+	// Assignment operator
+	IdComponent& operator=( const IdComponent& rhs );
+
+	// Default constructor
+	IdComponent();
+
+}; // end class IdComponent
+
+// BMR - including template member function implementation here to 
+// prevent compilation errors.  When the compilers support template
+// member functions in *.C files, move them to IdComponent.C.
+
+// This function makes sure that this IdComponent instance actually
+// represents an HDF5 component and that this HDF5 component is no longer
+// referenced, then calls the parent function p_close to close the
+// appropriate HDF5 component.  In addition, this identifier instance 
+// will delete itself.
+// Type is the class of the instance to whom this IdComponent object
+// belongs.
+/* 11/10/00 - BMR: commented this member function because many compilers
+   still have no support for member template function.  The function is
+   replaced by resetIdComponent in H5Idtemplates.h
+template <class Type>
+void IdComponent::reset( Type* parent ) 
+{
+   if( ref_count->noReference())  // ref_count is decremented here
+   {
+      if( id > 0 )
+         parent->p_close();  // which p_close depends on whom this 
+			     // IdComponent object belongs to
+      delete ref_count; // delete the reference counter
+      delete this;	// this IdComponent object deletes itself
+   }
+}
+*/
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Idtemplates.h b/c++/src/H5Idtemplates.h
new file mode 100644
index 0000000..442ca97
--- /dev/null
+++ b/c++/src/H5Idtemplates.h
@@ -0,0 +1,30 @@
+#ifndef _Reset_h
+#define _Reset_h
+
+#include "H5IdComponent.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+
+template <class Type>
+void resetIdComponent( 
+	Type* obj )	// pointer to object to be reset
+{
+   if( obj->noReference())  // ref count of this object is decremented here
+   {
+      if( obj->getId() > 0 )
+         obj->p_close();  // which p_close depends on whom this
+                             // IdComponent object belongs to
+      obj->reset();  // delete ref_count from IdComponent
+   }
+}
+
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Include.h b/c++/src/H5Include.h
new file mode 100644
index 0000000..c3ff064
--- /dev/null
+++ b/c++/src/H5Include.h
@@ -0,0 +1,8 @@
+// Added this line for CC to compile at this time.  Will remove it when
+// the problem of "Multiple declaration for RcsId" is fixed. BMR - 10/30/00
+#ifdef RCSID
+#undef RCSID
+#endif
+
+#include <hdf5.h>
+
diff --git a/c++/src/H5IntType.C b/c++/src/H5IntType.C
new file mode 100644
index 0000000..bc1e1bc
--- /dev/null
+++ b/c++/src/H5IntType.C
@@ -0,0 +1,78 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AbstractDs.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5AtomType.h"
+#include "H5IntType.h"
+#include "H5DataSet.h"
+#include "H5PredType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+IntType::IntType() {}
+
+// Copy constructor: makes copy of the original IntType object
+IntType::IntType( const IntType& original ) : AtomType( original ) {}
+
+// Creates a integer type using a predefined type
+IntType::IntType( const PredType& pred_type ) : AtomType()
+{
+   // use DataType::copy to make a copy of this predefined type
+   copy( pred_type );
+}
+
+// Creates a integer datatype using an existing id
+IntType::IntType( const hid_t existing_id ) : AtomType( existing_id ) {}
+
+// Gets the integer datatype of the specified dataset - will reimplement
+IntType::IntType( const DataSet& dataset ) : AtomType()
+{  
+   // Calls C function H5Dget_type to get the id of the datatype
+   id = H5Dget_type( dataset.getId() );
+
+   if( id <= 0 )
+   {
+      throw DataSetIException();
+   }
+}  
+
+// Retrieves the sign type for an integer type
+H5T_sign_t IntType::getSign() const
+{
+   H5T_sign_t type_sign = H5Tget_sign( id );  // C routine
+   // Returns a valid sign type if successful
+   if( type_sign == H5T_SGN_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   return( type_sign );
+}
+
+// Sets the sign proprety for an integer type. 
+void IntType::setSign( H5T_sign_t sign ) const
+{
+   // Call C routine to set the sign property
+   herr_t ret_value = H5Tset_sign( id, sign );
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// This destructor terminates access to the datatype
+IntType::~IntType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5IntType.h b/c++/src/H5IntType.h
new file mode 100644
index 0000000..56c4792
--- /dev/null
+++ b/c++/src/H5IntType.h
@@ -0,0 +1,36 @@
+#ifndef _H5IntType_H
+#define _H5IntType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+class IntType : public AtomType {
+   public:
+
+	// default constructor
+	IntType();
+
+	// Creates a integer datatype using an existing id
+	IntType( hid_t existing_id );
+
+	// Creates a integer type using a predefined type
+	IntType( const PredType& pred_type );
+
+	// Copy constructor: makes copy of IntType object
+	IntType( const IntType& original );
+
+	// Gets the integer datatype of the specified dataset
+	IntType( const DataSet& dataset );
+
+	// Retrieves the sign type for an integer type
+	H5T_sign_t getSign() const;
+
+	// Sets the sign proprety for an integer type. 
+	void setSign( H5T_sign_t sign ) const;
+
+	virtual ~IntType();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Library.C b/c++/src/H5Library.C
new file mode 100644
index 0000000..ffce037
--- /dev/null
+++ b/c++/src/H5Library.C
@@ -0,0 +1,67 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5Exception.h"
+#include "H5Library.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// This static variable will be set to true when dontAtExit is called
+bool H5Library::need_cleanup = false;
+
+// Initializes the HDF5 library. 
+void H5Library::open()
+{
+   herr_t ret_value = H5open();
+   if( ret_value < 0 )
+   {
+      throw LibraryIException();
+   }
+}
+
+// Flushes all data to disk, closes files, and cleans up memory. 
+void H5Library::close()
+{
+   herr_t ret_value = H5close();
+   if( ret_value < 0 )
+   {
+      throw LibraryIException();
+   }
+}
+
+// Instructs library not to install atexit cleanup routine
+void H5Library::dontAtExit()
+{
+   herr_t ret_value = H5dont_atexit();
+   if( ret_value < 0 )
+   {
+      throw LibraryIException();
+   }
+}
+
+// Returns the HDF library release number. 
+void H5Library::getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum )
+{
+   herr_t ret_value = H5get_libversion( &majnum, &minnum, &relnum );
+   if( ret_value < 0 )
+   {
+      throw LibraryIException();
+   }
+}
+
+// Verifies that the arguments match the version numbers compiled
+// into the library
+void H5Library::checkVersion( unsigned majnum, unsigned minnum, unsigned relnum )
+{
+   herr_t ret_value = H5check_version( majnum, minnum, relnum  );
+   if( ret_value < 0 )
+   {
+      throw LibraryIException();
+   }
+}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5Library.h b/c++/src/H5Library.h
new file mode 100644
index 0000000..ed2feef
--- /dev/null
+++ b/c++/src/H5Library.h
@@ -0,0 +1,42 @@
+#ifndef _H5Library_H
+#define _H5Library_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+#define NOTATEXIT       (-10)   // just in case the HDF5 library use more
+	// negative constants. Note: the solution used for the atexit/global
+	// destructors is not reliable, and desperately needs improvement 
+	// It is not even working, inifiteloop message still printed when
+	// calling H5close
+
+class H5Library {
+   public:
+	static bool need_cleanup; // indicates if H5close should be called
+
+	// Initializes the HDF5 library. 
+	static void open(); 
+
+	// Flushes all data to disk, closes files, and cleans up memory. 
+	static void close(); 
+
+	// Instructs library not to install atexit cleanup routine
+	static void dontAtExit(); 
+
+	// Returns the HDF library release number. 
+	static void getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum ); 
+
+	// Verifies that the arguments match the version numbers compiled
+	// into the library
+	static void checkVersion( unsigned majnum, unsigned minnum, unsigned relnum ); 
+
+   private:
+	// Default constructor - no instance ever created
+	H5Library() {};
+
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5Object.C b/c++/src/H5Object.C
new file mode 100644
index 0000000..82f7849
--- /dev/null
+++ b/c++/src/H5Object.C
@@ -0,0 +1,168 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5DataSpace.h"
+#include "H5AbstractDs.h"
+#include "H5Attribute.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// userAttrOpWrpr simply interfaces between the user's function and the
+// C library function H5Aiterate; used to resolve the different prototype 
+// problem.  May be moved to Iterator later.
+extern "C" herr_t userAttrOpWrpr( hid_t loc_id, const char* attr_name, void* op_data )
+{
+   string s_attr_name = string( attr_name );
+   UserData4Aiterate* myData = static_cast <UserData4Aiterate *> (op_data);
+   myData->op( *myData->object, s_attr_name, myData->opData );
+   return 0;
+}
+
+// Default constructor - set id to 0 by default here but may be set
+// to a valid HDF5 id, if any, by a subclass constructor.
+H5Object::H5Object() : IdComponent() {}
+
+// Constructs an object from an existing HDF5 id
+H5Object::H5Object( hid_t object_id ) : IdComponent( object_id ) {}
+
+// Copy constructor: makes a copy of the original H5Object instance
+H5Object::H5Object( const H5Object& original ) : IdComponent( original ) {}
+
+// Creates an attribute for a group, dataset, or named datatype.
+Attribute H5Object::createAttribute( const char* name, const DataType& data_type, const DataSpace& data_space, const PropList& create_plist ) const
+{
+   hid_t type_id = data_type.getId();
+   hid_t space_id = data_space.getId();
+   hid_t plist_id = create_plist.getId();
+   hid_t attr_id = H5Acreate( id, name, type_id, space_id, plist_id );
+
+   // If the attribute id is valid, create and return the Attribute object
+   if( attr_id > 0 )
+   {
+      Attribute attr( attr_id );
+      return( attr );
+   }
+   else
+   {
+      throw AttributeIException();
+   }
+}
+
+// Creates an attribute for a group, dataset, or named datatype.
+Attribute H5Object::createAttribute( const string& name, const DataType& data_type, const DataSpace& data_space, const PropList& create_plist ) const
+{
+   return( createAttribute( name.c_str(), data_type, data_space, create_plist ));
+}
+
+// Opens an attribute given its name; name is given as char*
+Attribute H5Object::openAttribute( const char* name ) const
+{
+   hid_t attr_id = H5Aopen_name( id, name );
+   if( attr_id > 0 )
+   {
+      Attribute attr( attr_id );
+      return( attr );
+   }
+   else
+   {
+      throw AttributeIException();
+   }
+}
+
+// Opens an attribute given its name; name is given as string
+Attribute H5Object::openAttribute( const string& name ) const
+{
+   return( openAttribute( name.c_str()) );
+}
+
+// Opens an attribute given its index.
+Attribute H5Object::openAttribute( unsigned int idx ) const
+{
+   hid_t attr_id = H5Aopen_idx( id, idx );
+   if( attr_id > 0 )
+   {
+      Attribute attr( attr_id );
+      return( attr );
+   }
+   else
+   {
+      throw AttributeIException();
+   }
+}
+
+// Iterates a user's function over all the attributes of the dataset
+int H5Object::iterateAttrs( attr_operator_t user_op, unsigned * idx, void *op_data )
+{
+   // store the user's function and data
+   UserData4Aiterate* userData = new UserData4Aiterate;
+   userData->opData = op_data;
+   userData->idx = idx;
+   userData->op = user_op;
+   userData->object = this;
+
+   // call the C library routine H5Aiterate to iterate the attributes
+   int ret_value = H5Aiterate( id, idx, userAttrOpWrpr, (void *) userData );
+   // release memory
+   delete userData;
+
+   if( ret_value >= 0 )
+      return( ret_value );
+   else  // raise exception when H5Aiterate returns a negative value
+   {
+      throw AttributeIException();
+   }
+}
+
+// Determines the number of attributes attached to 
+int H5Object::getNumAttrs() const
+{
+   int num_attrs = H5Aget_num_attrs( id );
+   if( num_attrs < 0 )
+   {
+      throw AttributeIException();
+   }
+   else
+      return( num_attrs );
+}
+
+// Removes the named attribute from this object.
+void H5Object::removeAttr( const char* name ) const
+{
+   herr_t ret_value = H5Adelete( id, name );
+   if( ret_value < 0 )
+   {
+      throw AttributeIException();
+   }
+}
+void H5Object::removeAttr( const string& name ) const
+{
+   removeAttr( name.c_str() );
+}
+
+// Flushes all buffers associated with a file to disk.
+void H5Object::flush(H5F_scope_t scope ) const
+{
+   herr_t ret_value = H5Fflush( id, scope );
+   if( ret_value < 0 )
+   {
+      throw FileIException();
+   }
+}
+
+// each subclass' destructor calls the template function resetIdComponent()
+// to reset the corresponding IdComponent object and close the HDF5 object
+// where appropriate.
+H5Object::~H5Object() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5Object.h b/c++/src/H5Object.h
new file mode 100644
index 0000000..65e7119
--- /dev/null
+++ b/c++/src/H5Object.h
@@ -0,0 +1,88 @@
+#ifndef _H5Object_H
+#define _H5Object_H
+
+#include "H5Classes.h"		// constains forward class declarations
+
+// H5Object is a baseclass.  It has these subclasses: 
+// Group, AbstractDs, and DataType. 
+// AbstractDs, in turn, has subclasses DataSet and Attribute.
+// DataType, in turn, has several specific datatypes as subclasses.
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class H5Object;  // forward declaration for UserData4Aiterate
+
+// Define the operator function pointer for H5Aiterate().
+typedef void (*attr_operator_t)( H5Object& loc/*in*/, 
+				 const string attr_name/*in*/, 
+				 void *operator_data/*in,out*/);
+
+class UserData4Aiterate { // user data for attribute iteration
+   public:
+	unsigned int* idx;
+	attr_operator_t op;
+	void* opData;
+	H5Object* object;
+};
+
+// The above part is being moved into Iterator, but not completed
+
+class H5Object : public IdComponent {
+   public:
+	// Pure virtual function so appropriate close function can 
+	// be called by subclasses' for the corresponding HDF5 object
+	//virtual void p_close() const = 0;
+
+	// Copy constructor: makes copy of an H5Object object.
+	H5Object( const H5Object& original );
+
+	// Flushes all buffers associated with this object to disk
+	void flush( H5F_scope_t scope ) const;
+
+	// Assignment operator
+	//H5Object& operator=( const H5Object& rhs );
+
+	// Sets and gets H5Object's data member
+	//void setId( hid_t new_id );
+	//hid_t getId () const;
+
+	// Creates an attribute for a group, dataset, or named datatype.
+	// PropList is currently not used, so always be default.
+	Attribute createAttribute( const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
+	Attribute createAttribute( const string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
+
+	// Opens an attribute given its name.
+	Attribute openAttribute( const string& name ) const;
+	Attribute openAttribute( const char* name ) const;
+
+	// Opens an attribute given its index.
+	Attribute openAttribute( const unsigned int idx ) const;
+
+	// Iterate user's function over the attributes of this object
+	int iterateAttrs( attr_operator_t user_op, unsigned* idx = NULL, void* op_data = NULL );
+
+	// Determines the number of attributes attached to this object.
+	int getNumAttrs() const;
+
+	// Removes the named attribute from this object.
+	void removeAttr( const string& name ) const;
+	void removeAttr( const char* name ) const;
+
+	virtual ~H5Object();
+
+   protected:
+
+	// Default constructor
+	H5Object();
+
+	// Creates a copy of an existing object giving the object id
+	H5Object( const hid_t object_id );
+
+}; /* end class H5Object */
+
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5PredType.C b/c++/src/H5PredType.C
new file mode 100644
index 0000000..deada00
--- /dev/null
+++ b/c++/src/H5PredType.C
@@ -0,0 +1,192 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AtomType.h"
+#include "H5Library.h"
+#include "H5PredType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor 
+PredType::PredType() : AtomType() {}
+
+// creates predefined datatype, so set DataType::is_predtype to true by default
+PredType::PredType( const hid_t predtype_id ) : AtomType( predtype_id )
+{ 
+   is_predtype = true; 
+}
+
+// Copy constructor: makes a copy of this PredType object.
+PredType::PredType( const PredType& original ) : AtomType( original ) {}
+
+const PredType PredType::NotAtexit;	// only for atexit/global dest. problem
+
+// Definition of pre-defined types
+const PredType PredType::C_S1( H5T_C_S1 );
+const PredType PredType::FORTRAN_S1( H5T_FORTRAN_S1 );
+
+const PredType PredType::STD_I8BE( H5T_STD_I8BE );
+const PredType PredType::STD_I8LE( H5T_STD_I8LE );
+const PredType PredType::STD_I16BE( H5T_STD_I16BE );
+const PredType PredType::STD_I16LE( H5T_STD_I16LE );
+const PredType PredType::STD_I32BE( H5T_STD_I32BE );
+const PredType PredType::STD_I32LE( H5T_STD_I32LE );
+const PredType PredType::STD_I64BE( H5T_STD_I64BE );
+const PredType PredType::STD_I64LE( H5T_STD_I64LE );
+const PredType PredType::STD_U8BE( H5T_STD_U8BE );
+const PredType PredType::STD_U8LE( H5T_STD_U8LE );
+const PredType PredType::STD_U16BE( H5T_STD_U16BE );
+const PredType PredType::STD_U16LE( H5T_STD_U16LE );
+const PredType PredType::STD_U32BE( H5T_STD_U32BE );
+const PredType PredType::STD_U32LE( H5T_STD_U32LE );
+const PredType PredType::STD_U64BE( H5T_STD_U64BE );
+const PredType PredType::STD_U64LE( H5T_STD_U64LE );
+const PredType PredType::STD_B8BE( H5T_STD_B8BE );
+const PredType PredType::STD_B8LE( H5T_STD_B8LE );
+const PredType PredType::STD_B16BE( H5T_STD_B16BE );
+const PredType PredType::STD_B16LE( H5T_STD_B16LE );
+const PredType PredType::STD_B32BE( H5T_STD_B32BE );
+const PredType PredType::STD_B32LE( H5T_STD_B32LE );
+const PredType PredType::STD_B64BE( H5T_STD_B64BE );
+const PredType PredType::STD_B64LE( H5T_STD_B64LE );
+const PredType PredType::STD_REF_OBJ( H5T_STD_REF_OBJ );
+const PredType PredType::STD_REF_DSETREG( H5T_STD_REF_DSETREG );
+
+const PredType PredType::IEEE_F32BE( H5T_IEEE_F32BE );
+const PredType PredType::IEEE_F32LE( H5T_IEEE_F32LE );
+const PredType PredType::IEEE_F64BE( H5T_IEEE_F64BE );
+const PredType PredType::IEEE_F64LE( H5T_IEEE_F64LE );
+
+const PredType PredType::UNIX_D32BE( H5T_UNIX_D32BE );
+const PredType PredType::UNIX_D32LE( H5T_UNIX_D32LE );
+const PredType PredType::UNIX_D64BE( H5T_UNIX_D64BE );
+const PredType PredType::UNIX_D64LE( H5T_UNIX_D64LE );
+
+const PredType PredType::INTEL_I8( H5T_INTEL_I8 );
+const PredType PredType::INTEL_I16( H5T_INTEL_I16 );
+const PredType PredType::INTEL_I32( H5T_INTEL_I32 );
+const PredType PredType::INTEL_I64( H5T_INTEL_I64 );
+const PredType PredType::INTEL_U8( H5T_INTEL_U8 );
+const PredType PredType::INTEL_U16( H5T_INTEL_U16 );
+const PredType PredType::INTEL_U32( H5T_INTEL_U32 );
+const PredType PredType::INTEL_U64( H5T_INTEL_U64 );
+const PredType PredType::INTEL_B8( H5T_INTEL_B8 );
+const PredType PredType::INTEL_B16( H5T_INTEL_B16 );
+const PredType PredType::INTEL_B32( H5T_INTEL_B32 );
+const PredType PredType::INTEL_B64( H5T_INTEL_B64 );
+const PredType PredType::INTEL_F32( H5T_INTEL_F32 );
+const PredType PredType::INTEL_F64( H5T_INTEL_F64 );
+
+const PredType PredType::ALPHA_I8( H5T_ALPHA_I8 );
+const PredType PredType::ALPHA_I16( H5T_ALPHA_I16 );
+const PredType PredType::ALPHA_I32( H5T_ALPHA_I32 );
+const PredType PredType::ALPHA_I64( H5T_ALPHA_I64 );
+const PredType PredType::ALPHA_U8( H5T_ALPHA_U8 );
+const PredType PredType::ALPHA_U16( H5T_ALPHA_U16 );
+const PredType PredType::ALPHA_U32( H5T_ALPHA_U32 );
+const PredType PredType::ALPHA_U64( H5T_ALPHA_U64 );
+const PredType PredType::ALPHA_B8( H5T_ALPHA_B8 );
+const PredType PredType::ALPHA_B16( H5T_ALPHA_B16 );
+const PredType PredType::ALPHA_B32( H5T_ALPHA_B32 );
+const PredType PredType::ALPHA_B64( H5T_ALPHA_B64 );
+const PredType PredType::ALPHA_F32( H5T_ALPHA_F32 );
+const PredType PredType::ALPHA_F64( H5T_ALPHA_F64 );
+
+const PredType PredType::MIPS_I8( H5T_MIPS_I8 );
+const PredType PredType::MIPS_I16( H5T_MIPS_I16 );
+const PredType PredType::MIPS_I32( H5T_MIPS_I32 );
+const PredType PredType::MIPS_I64( H5T_MIPS_I64 );
+const PredType PredType::MIPS_U8( H5T_MIPS_U8 );
+const PredType PredType::MIPS_U16( H5T_MIPS_U16 );
+const PredType PredType::MIPS_U32( H5T_MIPS_U32 );
+const PredType PredType::MIPS_U64( H5T_MIPS_U64 );
+const PredType PredType::MIPS_B8( H5T_MIPS_B8 );
+const PredType PredType::MIPS_B16( H5T_MIPS_B16 );
+const PredType PredType::MIPS_B32( H5T_MIPS_B32 );
+const PredType PredType::MIPS_B64( H5T_MIPS_B64 );
+const PredType PredType::MIPS_F32( H5T_MIPS_F32 );
+const PredType PredType::MIPS_F64( H5T_MIPS_F64 );
+
+const PredType PredType::NATIVE_CHAR( H5T_NATIVE_CHAR );
+const PredType PredType::NATIVE_INT( H5T_NATIVE_INT );
+const PredType PredType::NATIVE_FLOAT( H5T_NATIVE_FLOAT );
+const PredType PredType::NATIVE_SCHAR( H5T_NATIVE_SCHAR );
+const PredType PredType::NATIVE_UCHAR( H5T_NATIVE_UCHAR );
+const PredType PredType::NATIVE_SHORT( H5T_NATIVE_SHORT );
+const PredType PredType::NATIVE_USHORT( H5T_NATIVE_USHORT );
+const PredType PredType::NATIVE_UINT( H5T_NATIVE_UINT );
+const PredType PredType::NATIVE_LONG( H5T_NATIVE_LONG );
+const PredType PredType::NATIVE_ULONG( H5T_NATIVE_ULONG );
+const PredType PredType::NATIVE_LLONG( H5T_NATIVE_LLONG );
+const PredType PredType::NATIVE_ULLONG( H5T_NATIVE_ULLONG );
+const PredType PredType::NATIVE_DOUBLE( H5T_NATIVE_DOUBLE );
+const PredType PredType::NATIVE_LDOUBLE( H5T_NATIVE_LDOUBLE );
+const PredType PredType::NATIVE_B8( H5T_NATIVE_B8 );
+const PredType PredType::NATIVE_B16( H5T_NATIVE_B16 );
+const PredType PredType::NATIVE_B32( H5T_NATIVE_B32 );
+const PredType PredType::NATIVE_B64( H5T_NATIVE_B64 );
+const PredType PredType::NATIVE_OPAQUE( H5T_NATIVE_OPAQUE );
+const PredType PredType::NATIVE_HSIZE( H5T_NATIVE_HSIZE );
+const PredType PredType::NATIVE_HSSIZE( H5T_NATIVE_HSSIZE );
+const PredType PredType::NATIVE_HERR( H5T_NATIVE_HERR );
+const PredType PredType::NATIVE_HBOOL( H5T_NATIVE_HBOOL );
+
+const PredType PredType::NATIVE_INT8( H5T_NATIVE_INT8 );
+const PredType PredType::NATIVE_UINT8( H5T_NATIVE_UINT8 );
+const PredType PredType::NATIVE_INT_LEAST8( H5T_NATIVE_INT_LEAST8 );
+const PredType PredType::NATIVE_UINT_LEAST8( H5T_NATIVE_UINT_LEAST8 );
+const PredType PredType::NATIVE_INT_FAST8( H5T_NATIVE_INT_FAST8 );
+const PredType PredType::NATIVE_UINT_FAST8( H5T_NATIVE_UINT_FAST8 );
+
+const PredType PredType::NATIVE_INT16( H5T_NATIVE_INT16 );
+const PredType PredType::NATIVE_UINT16( H5T_NATIVE_UINT16 );
+const PredType PredType::NATIVE_INT_LEAST16( H5T_NATIVE_INT_LEAST16 );
+const PredType PredType::NATIVE_UINT_LEAST16( H5T_NATIVE_UINT_LEAST16 );
+const PredType PredType::NATIVE_INT_FAST16( H5T_NATIVE_INT_FAST16 );
+const PredType PredType::NATIVE_UINT_FAST16( H5T_NATIVE_UINT_FAST16 );
+
+const PredType PredType::NATIVE_INT32( H5T_NATIVE_INT32 );
+const PredType PredType::NATIVE_UINT32( H5T_NATIVE_UINT32 );
+const PredType PredType::NATIVE_INT_LEAST32( H5T_NATIVE_INT_LEAST32 );
+const PredType PredType::NATIVE_UINT_LEAST32( H5T_NATIVE_UINT_LEAST32 );
+const PredType PredType::NATIVE_INT_FAST32( H5T_NATIVE_INT_FAST32 );
+const PredType PredType::NATIVE_UINT_FAST32( H5T_NATIVE_UINT_FAST32 );
+
+const PredType PredType::NATIVE_INT64( H5T_NATIVE_INT64 );
+const PredType PredType::NATIVE_UINT64( H5T_NATIVE_UINT64 );
+const PredType PredType::NATIVE_INT_LEAST64( H5T_NATIVE_INT_LEAST64 );
+const PredType PredType::NATIVE_UINT_LEAST64( H5T_NATIVE_UINT_LEAST64 );
+const PredType PredType::NATIVE_INT_FAST64( H5T_NATIVE_INT_FAST64 );
+const PredType PredType::NATIVE_UINT_FAST64( H5T_NATIVE_UINT_FAST64 );
+
+// These dummy functions do not inherit from DataType - they'll
+// throw an DataTypeIException if invoked.
+void PredType::commit( H5Object& loc, const char* name )
+{
+   throw DataTypeIException( "Attempting to commit a predefined datatype.  This operation is invalid" );
+}  
+
+void PredType::commit( H5Object& loc, const string& name )
+{
+   commit( loc, name.c_str());
+}  
+
+bool PredType::committed()
+{
+   throw DataTypeIException( "Attempting to check for commit status on a predefined datatype.  This operation is invalid" );
+}  
+
+// Destructor: calls ~AtomType immediately
+PredType::~PredType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5PredType.h b/c++/src/H5PredType.h
new file mode 100644
index 0000000..15168fb
--- /dev/null
+++ b/c++/src/H5PredType.h
@@ -0,0 +1,181 @@
+// PredType holds the definition of all the HDF5 predefined datatypes.
+// These types can only be made copy of, not created by H5Tcreate or
+// closed by H5Tclose.  They are treated as constants.
+/////////////////////////////////////////////////////////////////////
+
+#ifndef _H5PredType_H
+#define _H5PredType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class PredType : public AtomType {
+   public:
+	// Default destructor
+	virtual ~PredType();
+
+	// Copy constructor - makes copy of the original object
+	PredType( const PredType& original );
+
+
+	// Declaration of predefined types; their definition is in Predtype.C
+	static const PredType STD_I8BE;
+	static const PredType STD_I8LE;
+	static const PredType STD_I16BE;
+	static const PredType STD_I16LE;
+	static const PredType STD_I32BE;
+	static const PredType STD_I32LE;
+	static const PredType STD_I64BE;
+	static const PredType STD_I64LE;
+	static const PredType STD_U8BE;
+	static const PredType STD_U8LE;
+	static const PredType STD_U16BE;
+	static const PredType STD_U16LE;
+	static const PredType STD_U32BE;
+	static const PredType STD_U32LE;
+	static const PredType STD_U64BE;
+	static const PredType STD_U64LE;
+	static const PredType STD_B8BE;
+	static const PredType STD_B8LE;
+	static const PredType STD_B16BE;
+	static const PredType STD_B16LE;
+	static const PredType STD_B32BE;
+	static const PredType STD_B32LE;
+	static const PredType STD_B64BE;
+	static const PredType STD_B64LE;
+	static const PredType STD_REF_OBJ;
+	static const PredType STD_REF_DSETREG;
+
+	static const PredType C_S1;
+	static const PredType FORTRAN_S1;
+
+	static const PredType IEEE_F32BE;
+	static const PredType IEEE_F32LE;
+	static const PredType IEEE_F64BE;
+	static const PredType IEEE_F64LE;
+
+	static const PredType UNIX_D32BE;
+	static const PredType UNIX_D32LE;
+	static const PredType UNIX_D64BE;
+	static const PredType UNIX_D64LE;
+
+	static const PredType INTEL_I8;
+	static const PredType INTEL_I16;
+	static const PredType INTEL_I32;
+	static const PredType INTEL_I64;
+	static const PredType INTEL_U8;
+	static const PredType INTEL_U16;
+	static const PredType INTEL_U32;
+	static const PredType INTEL_U64;
+	static const PredType INTEL_B8;
+	static const PredType INTEL_B16;
+	static const PredType INTEL_B32;
+	static const PredType INTEL_B64;
+	static const PredType INTEL_F32;
+	static const PredType INTEL_F64;
+
+	static const PredType ALPHA_I8;
+	static const PredType ALPHA_I16;
+	static const PredType ALPHA_I32;
+	static const PredType ALPHA_I64;
+	static const PredType ALPHA_U8;
+	static const PredType ALPHA_U16;
+	static const PredType ALPHA_U32;
+	static const PredType ALPHA_U64;
+	static const PredType ALPHA_B8;
+	static const PredType ALPHA_B16;
+	static const PredType ALPHA_B32;
+	static const PredType ALPHA_B64;
+	static const PredType ALPHA_F32;
+	static const PredType ALPHA_F64;
+
+	static const PredType MIPS_I8;
+	static const PredType MIPS_I16;
+	static const PredType MIPS_I32;
+	static const PredType MIPS_I64;
+	static const PredType MIPS_U8;
+	static const PredType MIPS_U16;
+	static const PredType MIPS_U32;
+	static const PredType MIPS_U64;
+	static const PredType MIPS_B8;
+	static const PredType MIPS_B16;
+	static const PredType MIPS_B32;
+	static const PredType MIPS_B64;
+	static const PredType MIPS_F32;
+	static const PredType MIPS_F64;
+
+	static const PredType NATIVE_CHAR;
+	static const PredType NATIVE_SCHAR;
+	static const PredType NATIVE_UCHAR;
+	static const PredType NATIVE_SHORT;
+	static const PredType NATIVE_USHORT;
+	static const PredType NATIVE_INT;
+	static const PredType NATIVE_UINT;
+	static const PredType NATIVE_LONG;
+	static const PredType NATIVE_ULONG;
+	static const PredType NATIVE_LLONG;
+	static const PredType NATIVE_ULLONG;
+	static const PredType NATIVE_FLOAT;
+	static const PredType NATIVE_DOUBLE;
+	static const PredType NATIVE_LDOUBLE;
+	static const PredType NATIVE_B8;
+	static const PredType NATIVE_B16;
+	static const PredType NATIVE_B32;
+	static const PredType NATIVE_B64;
+	static const PredType NATIVE_OPAQUE;
+	static const PredType NATIVE_HSIZE;
+	static const PredType NATIVE_HSSIZE;
+	static const PredType NATIVE_HERR;
+	static const PredType NATIVE_HBOOL;
+
+	static const PredType NATIVE_INT8;
+	static const PredType NATIVE_UINT8;
+	static const PredType NATIVE_INT_LEAST8;
+	static const PredType NATIVE_UINT_LEAST8;
+	static const PredType NATIVE_INT_FAST8;
+	static const PredType NATIVE_UINT_FAST8;
+
+	static const PredType NATIVE_INT16;
+	static const PredType NATIVE_UINT16;
+	static const PredType NATIVE_INT_LEAST16;
+	static const PredType NATIVE_UINT_LEAST16;
+	static const PredType NATIVE_INT_FAST16;
+	static const PredType NATIVE_UINT_FAST16;
+
+	static const PredType NATIVE_INT32;
+	static const PredType NATIVE_UINT32;
+	static const PredType NATIVE_INT_LEAST32;
+	static const PredType NATIVE_UINT_LEAST32;
+	static const PredType NATIVE_INT_FAST32;
+	static const PredType NATIVE_UINT_FAST32;
+
+	static const PredType NATIVE_INT64;
+	static const PredType NATIVE_UINT64;
+	static const PredType NATIVE_INT_LEAST64;
+	static const PredType NATIVE_UINT_LEAST64;
+	static const PredType NATIVE_INT_FAST64;
+	static const PredType NATIVE_UINT_FAST64;
+
+	// These dummy functions do not inherit from DataType - they'll
+	// throw a DataTypeIException if invoked.
+	void commit( H5Object& loc, const string& name );
+	void commit( H5Object& loc, const char* name );
+	bool committed();
+
+   private:
+	// added this to work around the atexit/global destructor problem 
+	// temporarily - it'll prevent the use of atexit to clean up
+	static const PredType NotAtexit;
+
+   protected:
+	// Default constructor
+	PredType();
+
+	// Creates a pre-defined type using an HDF5 pre-defined constant
+	PredType( const hid_t predtype_id );  // used by the library only
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5PropList.C b/c++/src/H5PropList.C
new file mode 100644
index 0000000..5279be0
--- /dev/null
+++ b/c++/src/H5PropList.C
@@ -0,0 +1,103 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5PropList.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const PropList PropList::DEFAULT( H5P_DEFAULT );
+
+// Default constructor - set id to 0 by default here but may be set
+// to a valid one, if any, by a subclass constructor.
+PropList::PropList() : IdComponent( 0 )
+{
+//   id_obj = new IdComponent( 0 );  // init default object's id to 0
+}
+
+// Creates a new property of specified type
+PropList::PropList( H5P_class_t type ) : IdComponent( 0 )
+{
+   // call C routine to create the new property
+   id = H5Pcreate(type );
+   if( id <= 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Copy constructor: makes a copy of the original object
+PropList::PropList( const PropList& original ) : IdComponent( original ) {}
+
+/* Constructor that takes an existing property list id.
+Description:
+	Uses an HDF5 id to create a PropList identifier object.  This id
+	can be either an existing property list id or a default property
+	list id.  Design note: in the case of default property list,
+	the identifier still has reference counter; the p_close function
+	will take care of not to call H5Pclose on the default id.
+*/
+PropList::PropList( const hid_t plist_id ) : IdComponent( plist_id ) { }
+
+// Makes a copy of an existing property list 
+void PropList::copy( const PropList& like_plist )
+{
+   // reset the identifier of this PropList - send 'this' in so that
+   // H5Pclose can be called appropriately
+   resetIdComponent( this );
+
+   // call C routine to copy the property list
+   id = H5Pcopy( like_plist.getId() );
+
+   // points to the same ref counter
+   ref_count = like_plist.ref_count;
+
+   // increment ref counter to indicate additional references to this id
+   ref_count->increment();
+
+   if( id <= 0 )
+   {
+      throw PropListIException();
+   }
+}
+
+// Closes the property list if it is not a default one
+void PropList::p_close() const
+{
+   if( id != H5P_DEFAULT ) // not a constant, should call H5Pclose
+   {
+      herr_t ret_value = H5Pclose( id );
+      if( ret_value < 0 )
+      {
+         throw PropListIException("PropList::p_close: unable to close the property list.  Please report this bug to HDF." );
+      }
+   }
+}
+
+// Returns the class of this property list, i.e. H5P_FILE_CREATE...
+H5P_class_t PropList::getClass() const
+{
+   H5P_class_t plist_class = H5Pget_class( id );
+   if( plist_class == H5P_NO_CLASS )
+   {
+      throw PropListIException();
+   }
+   return( plist_class );
+}
+
+// The destructor of this instance calls the template resetIdComponent to
+// reset its identifier
+PropList::~PropList()
+{  
+   // The property list id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5PropList.h b/c++/src/H5PropList.h
new file mode 100644
index 0000000..5e4a656
--- /dev/null
+++ b/c++/src/H5PropList.h
@@ -0,0 +1,50 @@
+#ifndef _H5PropList_H
+#define _H5PropList_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class PropList : public IdComponent {
+   public:
+	// Default property list
+        static const PropList DEFAULT;
+
+	// Creates a property list given the property list type.
+	PropList( H5P_class_t type );
+
+	// Default constructor: creates a PropList object - this object
+	// does not represent any property list yet.
+	PropList();
+
+	// Copy constructor: creates a copy of a PropList object.
+	PropList( const PropList& original );
+
+	// Makes a copy of the given property list.
+	void copy( const PropList& like_plist );
+
+	// Make a copy of the given property list using assignment statement
+	//PropList& operator=( const PropList& rhs );
+
+	// Sets and gets PropList's data member
+        //hid_t getId () const;
+        //void setId( hid_t new_plist_id );
+
+	// Gets the class of this property list, i.e. H5P_FILE_CREATE,
+	// H5P_FILE_ACCESS, ...
+	H5P_class_t getClass() const;
+
+	// Creates a default property list or creates a copy of an 
+	// existing property list giving the property list id
+	PropList( const hid_t plist_id );
+
+	// Used by the API to close the property list
+	void p_close() const;
+
+	virtual ~PropList();
+};
+
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif  // _H5PropList_H
diff --git a/c++/src/H5RefCounter.C b/c++/src/H5RefCounter.C
new file mode 100644
index 0000000..f98f7d1
--- /dev/null
+++ b/c++/src/H5RefCounter.C
@@ -0,0 +1,35 @@
+#include "H5RefCounter.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+using namespace std;
+#endif
+
+// Creates a reference counter to be used by an HDF5 object
+RefCounter::RefCounter() : counter(1) { }; 
+ 
+// Returns the current value of the reference counter
+int RefCounter::getCounter () const { return counter; }
+
+// Increments the reference counter as a copy of the object that uses
+// this counter is created.
+void RefCounter::increment() { counter++; }
+
+// Decrements the reference counter as a copy of the object that uses
+// this counter is destroyed.
+void RefCounter::decrement() { counter--; }
+
+// Decrements the reference counter then determines if there are no more 
+// reference to the object that uses this counter
+bool RefCounter::noReference()
+{
+   if( counter > 0 )
+      counter--;
+   return( counter == 0 ? true:false );
+}
+
+RefCounter::~RefCounter() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5RefCounter.h b/c++/src/H5RefCounter.h
new file mode 100644
index 0000000..dec1b3c
--- /dev/null
+++ b/c++/src/H5RefCounter.h
@@ -0,0 +1,29 @@
+#ifndef _H5RefCounter_H
+#define _H5RefCounter_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class RefCounter {
+   public:
+	// Creates a reference counter to be used by an HDF5 object
+	RefCounter();
+
+        int getCounter () const;
+        void increment();
+        void decrement();
+
+	// this bool function is used to determine whether to close an
+	// HDF5 object when there are no more reference to that object
+	bool noReference();
+
+	~RefCounter();
+
+   private:
+	int counter; // keeps track of number of copies of an object
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif
diff --git a/c++/src/H5StrType.C b/c++/src/H5StrType.C
new file mode 100644
index 0000000..51840db
--- /dev/null
+++ b/c++/src/H5StrType.C
@@ -0,0 +1,103 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5RefCounter.h"
+#include "H5Exception.h"
+#include "H5IdComponent.h"
+#include "H5PropList.h"
+#include "H5Object.h"
+#include "H5DataType.h"
+#include "H5AtomType.h"
+#include "H5AbstractDs.h"
+#include "H5DxferProp.h"
+#include "H5DataSpace.h"
+#include "H5StrType.h"
+#include "H5DataSet.h"
+#include "H5PredType.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+// Default constructor
+StrType::StrType() : AtomType() {}
+
+// Creates a string type using a predefined type
+StrType::StrType( const PredType& pred_type ) : AtomType()
+{
+   // use DataType::copy to make a copy of this predefined type
+   copy( pred_type );
+}
+
+// Creates a string datatype using an existing id
+StrType::StrType( const hid_t existing_id ) : AtomType( existing_id ) {}
+
+// Copy constructor: makes copy of the original StrType object
+StrType::StrType( const StrType& original ) : AtomType ( original ) {}
+
+// Gets the string datatype of the specified dataset - will reimplement
+StrType::StrType( const DataSet& dataset ) : AtomType ()
+{
+   // Calls C function H5Dget_type to get the id of the datatype
+   id = H5Dget_type( dataset.getId() );
+
+   if( id <= 0 )
+   {
+      throw DataSetIException();
+   }
+}
+
+// Retrieves the character set type of a string datatype. 
+H5T_cset_t StrType::getCset() const
+{
+   H5T_cset_t cset = H5Tget_cset( id );
+
+   // Returns a valid character set type if successful
+   if( cset == H5T_CSET_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   return( cset );
+}
+
+// Sets character set to be used. 
+void StrType::setCset( H5T_cset_t cset ) const
+{
+   herr_t ret_value = H5Tset_cset( id, cset );
+
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// Retrieves the string padding method for a string datatype. 
+H5T_str_t StrType::getStrpad() const
+{
+   H5T_str_t strpad = H5Tget_strpad( id );
+
+   // Returns a valid string padding type if successful
+   if( strpad == H5T_STR_ERROR )
+   {
+      throw DataTypeIException();
+   }
+   return( strpad );
+}
+
+// Defines the storage mechanism for character strings. 
+void StrType::setStrpad( H5T_str_t strpad ) const
+{
+   herr_t ret_value = H5Tset_strpad( id, strpad );
+
+   if( ret_value < 0 )
+   {
+      throw DataTypeIException();
+   }
+}
+
+// This destructor terminates access to the datatype
+StrType::~StrType() {}
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif
diff --git a/c++/src/H5StrType.h b/c++/src/H5StrType.h
new file mode 100644
index 0000000..2ba6779
--- /dev/null
+++ b/c++/src/H5StrType.h
@@ -0,0 +1,42 @@
+#ifndef _H5StrType_H
+#define _H5StrType_H
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+class StrType : public AtomType {
+   public:
+	// default constructor 
+	StrType();
+
+	// Creates a string type using a predefined type
+	StrType( const PredType& pred_type );
+
+	// Creates a string datatype using an existing id
+	StrType( hid_t existing_id );
+
+	// Copy constructor - makes a copy of the original object
+	StrType( const StrType& original );
+
+        // Gets the string datatype of the specified dataset 
+	StrType( const DataSet& dataset );
+
+	// Retrieves the character set type of this string datatype. 
+	H5T_cset_t getCset() const;
+
+	// Sets character set to be used. 
+	void setCset( H5T_cset_t cset ) const;
+
+	// Retrieves the string padding method for this string datatype. 
+	H5T_str_t getStrpad() const;
+
+	// Defines the storage mechanism for character strings. 
+	void setStrpad( H5T_str_t strpad ) const;
+
+	virtual ~StrType();
+};
+#ifndef H5_NO_NAMESPACE
+}
+#endif
+#endif