Format changes only.

Platforms tested:
    Linux/32 2.6 (jam) - very minor

52 files changed, 2552 insertions, 2552 deletions

diff --git a/c++/src/H5AbstractDs.cpp b/c++/src/H5AbstractDs.cpp
index 7568404..7642be6 100644
--- a/c++/src/H5AbstractDs.cpp
+++ b/c++/src/H5AbstractDs.cpp
@@ -59,42 +59,42 @@ AbstractDs::AbstractDs(){}
 //--------------------------------------------------------------------------
 H5T_class_t AbstractDs::getTypeClass() const
 {
-   // Gets the datatype used by this dataset or attribute.
-   // p_get_type calls either H5Dget_type or H5Aget_type depending on
-   // which object invokes getTypeClass
-   hid_t datatype_id;
-   try {
+    // Gets the datatype used by this dataset or attribute.
+    // p_get_type calls either H5Dget_type or H5Aget_type depending on
+    // which object invokes getTypeClass
+    hid_t datatype_id;
+    try {
       datatype_id = p_get_type();  // returned value is already validated
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getTypeClass", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getTypeClass", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getTypeClass", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getTypeClass", E.getDetailMsg());
+    }
 
-   // Gets the class of the datatype and validate it before returning
-   H5T_class_t type_class = H5Tget_class(datatype_id);
+    // Gets the class of the datatype and validate it before returning
+    H5T_class_t type_class = H5Tget_class(datatype_id);
 
-   // Close temporary datatype_id
-   herr_t ret_value = H5Tclose(datatype_id);
-   if (ret_value < 0)
-   {
-      if (fromClass() == "DataSet")
-         throw DataTypeIException("DataSet::getTypeClass", "H5Tclose failed");
-      else if (fromClass() == "Attribute")
-         throw DataTypeIException("Attribute::getTypeClass", "H5Tclose failed");
-   }
+    // Close temporary datatype_id
+    herr_t ret_value = H5Tclose(datatype_id);
+    if (ret_value < 0)
+    {
+        if (fromClass() == "DataSet")
+            throw DataTypeIException("DataSet::getTypeClass", "H5Tclose failed");
+    else if (fromClass() == "Attribute")
+            throw DataTypeIException("Attribute::getTypeClass", "H5Tclose failed");
+    }
 
-   // Check on the returned type_class
-   if (type_class == H5T_NO_CLASS)
-   {
-      if (fromClass() == "DataSet")
-         throw DataTypeIException("DataSet::getTypeClass", "H5Tget_class returns H5T_NO_CLASS");
-      else if (fromClass() == "Attribute")
-         throw DataTypeIException("Attribute::getTypeClass", "H5Tget_class returns H5T_NO_CLASS");
-   }
-   return(type_class);
+    // Check on the returned type_class
+    if (type_class == H5T_NO_CLASS)
+    {
+        if (fromClass() == "DataSet")
+        throw DataTypeIException("DataSet::getTypeClass", "H5Tget_class returns H5T_NO_CLASS");
+    else if (fromClass() == "Attribute")
+        throw DataTypeIException("Attribute::getTypeClass", "H5Tget_class returns H5T_NO_CLASS");
+    }
+    return(type_class);
 }
 
 //--------------------------------------------------------------------------
@@ -107,21 +107,21 @@ H5T_class_t AbstractDs::getTypeClass() const
 //--------------------------------------------------------------------------
 DataType AbstractDs::getDataType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getDataType.  Then, create and
-   // return the DataType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getDataType.  Then, create and
+    // return the DataType object
+    try {
         DataType datatype;
         f_DataType_setId(&datatype, p_get_type());
         return(datatype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getDataType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getDataType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getDataType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getDataType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -134,23 +134,23 @@ DataType AbstractDs::getDataType() const
 //--------------------------------------------------------------------------
 ArrayType AbstractDs::getArrayType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getArrayType.  Then, create and
-   // return the ArrayType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getArrayType.  Then, create and
+    // return the ArrayType object
+    try {
         // Create ArrayType and set values this way to work around the
         // problem described in the JIRA issue HDFFV-7947
         ArrayType arraytype;
         f_DataType_setId(&arraytype, p_get_type());
         return(arraytype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getArrayType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getArrayType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getArrayType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getArrayType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -163,21 +163,21 @@ ArrayType AbstractDs::getArrayType() const
 //--------------------------------------------------------------------------
 CompType AbstractDs::getCompType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getCompType.  Then, create and
-   // return the CompType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getCompType.  Then, create and
+    // return the CompType object
+    try {
         CompType comptype;
         f_DataType_setId(&comptype, p_get_type());
         return(comptype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getCompType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getCompType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getCompType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getCompType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -190,21 +190,21 @@ CompType AbstractDs::getCompType() const
 //--------------------------------------------------------------------------
 EnumType AbstractDs::getEnumType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getEnumType.  Then, create and
-   // return the EnumType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getEnumType.  Then, create and
+    // return the EnumType object
+    try {
         EnumType enumtype;
         f_DataType_setId(&enumtype, p_get_type());
         return(enumtype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getEnumType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getEnumType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getEnumType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getEnumType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -217,21 +217,21 @@ EnumType AbstractDs::getEnumType() const
 //--------------------------------------------------------------------------
 IntType AbstractDs::getIntType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getIntType.  Then, create and
-   // return the IntType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getIntType.  Then, create and
+    // return the IntType object
+    try {
         IntType inttype;
         f_DataType_setId(&inttype, p_get_type());
         return(inttype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getIntType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getIntType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getIntType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getIntType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -244,21 +244,21 @@ IntType AbstractDs::getIntType() const
 //--------------------------------------------------------------------------
 FloatType AbstractDs::getFloatType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getFloatType.  Then, create and
-   // return the FloatType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getFloatType.  Then, create and
+    // return the FloatType object
+    try {
         FloatType floatype;
         f_DataType_setId(&floatype, p_get_type());
         return(floatype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getFloatType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getFloatType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getFloatType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getFloatType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -271,21 +271,21 @@ FloatType AbstractDs::getFloatType() const
 //--------------------------------------------------------------------------
 StrType AbstractDs::getStrType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getStrType.  Then, create and
-   // return the StrType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getStrType.  Then, create and
+    // return the StrType object
+    try {
         StrType strtype;
         f_DataType_setId(&strtype, p_get_type());
         return(strtype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getStrType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getStrType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getStrType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getStrType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -298,21 +298,21 @@ StrType AbstractDs::getStrType() const
 //--------------------------------------------------------------------------
 VarLenType AbstractDs::getVarLenType() const
 {
-   // Gets the id of the datatype used by this dataset or attribute using
-   // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
-   // depending on which object invokes getVarLenType.  Then, create and
-   // return the VarLenType object
-   try {
+    // Gets the id of the datatype used by this dataset or attribute using
+    // p_get_type.  p_get_type calls either H5Dget_type or H5Aget_type
+    // depending on which object invokes getVarLenType.  Then, create and
+    // return the VarLenType object
+    try {
         VarLenType varlentype;
         f_DataType_setId(&varlentype, p_get_type());
         return(varlentype);
-   }
-   catch (DataSetIException& E) {
-      throw DataTypeIException("DataSet::getVarLenType", E.getDetailMsg());
-   }
-   catch (AttributeIException& E) {
-      throw DataTypeIException("Attribute::getVarLenType", E.getDetailMsg());
-   }
+    }
+    catch (DataSetIException& E) {
+        throw DataTypeIException("DataSet::getVarLenType", E.getDetailMsg());
+    }
+    catch (AttributeIException& E) {
+        throw DataTypeIException("Attribute::getVarLenType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5AbstractDs.h b/c++/src/H5AbstractDs.h
index 547485c..516188a 100644
--- a/c++/src/H5AbstractDs.h
+++ b/c++/src/H5AbstractDs.h
@@ -86,7 +86,7 @@ class H5_DLLCPP AbstractDs {
         // Mar 2016 -BMR, AbstractDs(const hid_t h5_id);
 
         // Copy constructor
-        // AbstractDs( const AbstractDs& original );
+        // AbstractDs(const AbstractDs& original);
 
    private:
         // This member function is implemented by DataSet and Attribute - pure virtual.
diff --git a/c++/src/H5ArrayType.cpp b/c++/src/H5ArrayType.cpp
index 658946b..c99e880 100644
--- a/c++/src/H5ArrayType.cpp
+++ b/c++/src/H5ArrayType.cpp
@@ -42,7 +42,7 @@ ArrayType::ArrayType() : DataType() {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - May 2004
 //--------------------------------------------------------------------------
-ArrayType::ArrayType( const hid_t existing_id ) : DataType( existing_id ) {}
+ArrayType::ArrayType(const hid_t existing_id) : DataType( existing_id ) {}
 
 //--------------------------------------------------------------------------
 // Function:    ArrayType copy constructor
diff --git a/c++/src/H5ArrayType.h b/c++/src/H5ArrayType.h
index 1ba0e5c..d55a767 100644
--- a/c++/src/H5ArrayType.h
+++ b/c++/src/H5ArrayType.h
@@ -45,10 +45,10 @@ class H5_DLLCPP ArrayType : public DataType {
         virtual H5std_string fromClass () const { return("ArrayType"); }
 
         // Copy constructor: makes copy of the original object.
-        ArrayType( const ArrayType& original );
+        ArrayType(const ArrayType& original);
 
         // Constructor that takes an existing id
-        ArrayType( const hid_t existing_id );
+        ArrayType(const hid_t existing_id);
 
         // Noop destructor
         virtual ~ArrayType();
diff --git a/c++/src/H5AtomType.cpp b/c++/src/H5AtomType.cpp
index 172f625..3b801ba 100644
--- a/c++/src/H5AtomType.cpp
+++ b/c++/src/H5AtomType.cpp
@@ -43,14 +43,14 @@ AtomType::AtomType() : DataType() {}
 // Exception    H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-AtomType::AtomType( const hid_t existing_id ) : DataType( existing_id ) {}
+AtomType::AtomType(const hid_t existing_id) : DataType( existing_id ) {}
 
 //--------------------------------------------------------------------------
 // Function:    AtomType copy constructor
 ///\brief       Copy constructor: makes a copy of the original AtomType object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-AtomType::AtomType( const AtomType& original ) : DataType( original ) {}
+AtomType::AtomType(const AtomType& original) : DataType( original ) {}
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 //--------------------------------------------------------------------------
@@ -60,14 +60,14 @@ AtomType::AtomType( const AtomType& original ) : DataType( original ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::setSize( size_t size ) const
+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(inMemFunc("setSize"), "H5Tset_size failed");
-   }
+    // Call C routine H5Tset_size to set the total size
+    herr_t ret_value = H5Tset_size(id, size);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setSize"), "H5Tset_size failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -82,16 +82,16 @@ void AtomType::setSize( size_t size ) const
 //--------------------------------------------------------------------------
 H5T_order_t AtomType::getOrder() const
 {
-   // Call C routine to get the byte ordering
-   H5T_order_t type_order = H5Tget_order( id );
+    // 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(inMemFunc("getOrder"),
+    // return a byte order constant if successful
+    if(type_order == H5T_ORDER_ERROR)
+    {
+        throw DataTypeIException(inMemFunc("getOrder"),
                 "H5Tget_order returns H5T_ORDER_ERROR");
-   }
-   return( type_order );
+    }
+    return(type_order);
 }
 
 //--------------------------------------------------------------------------
@@ -111,19 +111,19 @@ H5T_order_t AtomType::getOrder() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5T_order_t AtomType::getOrder( H5std_string& order_string ) const
+H5T_order_t AtomType::getOrder(H5std_string& order_string) const
 {
-   // Call the overloaded to get the type order without text
-   H5T_order_t type_order = getOrder();
+    // Call the overloaded to get the type order without text
+    H5T_order_t type_order = getOrder();
 
-   // Then provide the text and return the type order
-   if( type_order == H5T_ORDER_LE )
+    // Then provide the text and return the type order
+    if(type_order == H5T_ORDER_LE)
       order_string = "Little endian byte ordering (0)";
-   else if( type_order == H5T_ORDER_BE )
+    else if(type_order == H5T_ORDER_BE)
       order_string = "Big endian byte ordering (1)";
-   else if( type_order == H5T_ORDER_VAX )
+    else if(type_order == H5T_ORDER_VAX)
       order_string = "VAX mixed byte ordering (2)";
-   return( type_order );
+    return(type_order);
 }
 
 //--------------------------------------------------------------------------
@@ -136,14 +136,14 @@ H5T_order_t AtomType::getOrder( H5std_string& order_string ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::setOrder( H5T_order_t order ) const
+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(inMemFunc("setOrder"), "H5Tset_order failed");
-   }
+    // Call C routine to set the byte ordering
+    herr_t ret_value = H5Tset_order(id, order);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setOrder"), "H5Tset_order failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -159,15 +159,15 @@ void AtomType::setOrder( H5T_order_t order ) const
 //--------------------------------------------------------------------------
 size_t AtomType::getPrecision() const
 {
-   size_t num_signi_bits = H5Tget_precision( id );  // C routine
+    size_t num_signi_bits = H5Tget_precision(id);  // C routine
 
-   // returns number of significant bits if successful
-   if( num_signi_bits == 0 )
-   {
-      throw DataTypeIException(inMemFunc("getPrecision"),
+    // returns number of significant bits if successful
+    if(num_signi_bits == 0)
+    {
+        throw DataTypeIException(inMemFunc("getPrecision"),
                 "H5Tget_precision returns invalid number of significant bits");
-   }
-   return( num_signi_bits );
+    }
+    return(num_signi_bits);
 }
 
 //--------------------------------------------------------------------------
@@ -180,14 +180,14 @@ size_t AtomType::getPrecision() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5T.html#Datatype-SetPrecision
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::setPrecision( size_t precision ) const
+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(inMemFunc("setPrecision"), "H5Tset_precision failed");
-   }
+    // Call C routine to set the datatype precision
+    herr_t ret_value = H5Tset_precision(id, precision);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setPrecision"), "H5Tset_precision failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -206,15 +206,15 @@ void AtomType::setPrecision( size_t precision ) const
 //--------------------------------------------------------------------------
 int AtomType::getOffset() const
 {
-   int offset = H5Tget_offset( id );  // C routine
+    int offset = H5Tget_offset(id);  // C routine
 
-   // returns a non-negative offset value if successful
-   if( offset == -1 )
-   {
-      throw DataTypeIException(inMemFunc("getOffset"),
+    // returns a non-negative offset value if successful
+    if(offset == -1)
+    {
+        throw DataTypeIException(inMemFunc("getOffset"),
                 "H5Tget_offset returns a negative offset value");
-   }
-   return( offset );
+    }
+    return(offset);
 }
 
 //--------------------------------------------------------------------------
@@ -227,14 +227,14 @@ int AtomType::getOffset() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5T.html#Datatype-SetOffset
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::setOffset( size_t offset ) const
+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(inMemFunc("setOffset"), "H5Tset_offset failed");
-   }
+    // Call C routine to set the bit offset
+    herr_t ret_value = H5Tset_offset(id, offset);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setOffset"), "H5Tset_offset failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -251,14 +251,14 @@ void AtomType::setOffset( size_t offset ) const
 ///             \li \c H5T_PAD_BACKGROUND (2) - Leave background alone.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::getPad( H5T_pad_t& lsb, H5T_pad_t& msb ) const
+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(inMemFunc("getPad"), "H5Tget_pad failed");
-   }
+    // Call C routine to get the padding type
+    herr_t ret_value = H5Tget_pad(id, &lsb, &msb);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("getPad"), "H5Tget_pad failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -274,14 +274,14 @@ void AtomType::getPad( H5T_pad_t& lsb, H5T_pad_t& msb ) const
 ///             \li \c H5T_PAD_BACKGROUND (2) - Leave background alone.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void AtomType::setPad( H5T_pad_t lsb, H5T_pad_t msb ) const
+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(inMemFunc("setPad"), "H5Tset_pad failed");
-   }
+    // Call C routine to set the padding type
+    herr_t ret_value = H5Tset_pad(id, lsb, msb);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setPad"), "H5Tset_pad failed");
+    }
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/c++/src/H5AtomType.h b/c++/src/H5AtomType.h
index ca48b92..c588f38 100644
--- a/c++/src/H5AtomType.h
+++ b/c++/src/H5AtomType.h
@@ -31,39 +31,39 @@ class H5_DLLCPP AtomType : public DataType {
    public:
         // Returns the byte order of an atomic datatype.
         H5T_order_t getOrder() const;
-        H5T_order_t getOrder( H5std_string& order_string ) const;
+        H5T_order_t getOrder(H5std_string& order_string) const;
 
         // Sets the byte ordering of an atomic datatype.
-        void setOrder( H5T_order_t order ) const;
+        void setOrder(H5T_order_t order) const;
 
         // Retrieves the bit offset of the first significant bit.
         // 12/05/00 - changed return type to int from size_t - C API
         int getOffset() const;
 
         // Sets the bit offset of the first significant bit.
-        void setOffset( size_t offset ) const;
+        void setOffset(size_t offset) const;
 
         // Retrieves the padding type of the least and most-significant bit padding.
-        void getPad( H5T_pad_t& lsb, H5T_pad_t& msb ) const;
+        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;
+        void setPad(H5T_pad_t lsb, H5T_pad_t msb) 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;
+        void setPrecision(size_t precision) const;
 
         // Sets the total size for an atomic datatype.
-        void setSize( size_t size ) const;
+        void setSize(size_t size) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("AtomType"); }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
         // Copy constructor - makes copy of the original object
-        AtomType( const AtomType& original );
+        AtomType(const AtomType& original);
 
         // Noop destructor
         virtual ~AtomType();
@@ -75,7 +75,7 @@ class H5_DLLCPP AtomType : public DataType {
         AtomType();
 
         // Constructor that takes an existing id
-        AtomType( const hid_t existing_id );
+        AtomType(const hid_t existing_id);
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 }; // end of AtomType
diff --git a/c++/src/H5Attribute.cpp b/c++/src/H5Attribute.cpp
index 3162151..00407bc 100644
--- a/c++/src/H5Attribute.cpp
+++ b/c++/src/H5Attribute.cpp
@@ -84,13 +84,13 @@ Attribute::Attribute(const hid_t existing_id) : AbstractDs(), IdComponent(), id(
 ///\exception   H5::AttributeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void Attribute::write( const DataType& mem_type, const void *buf ) const
+void Attribute::write(const DataType& mem_type, const void *buf) const
 {
-   herr_t ret_value = H5Awrite( id, mem_type.getId(), buf );
-   if( ret_value < 0 )
-   {
-      throw AttributeIException("Attribute::write", "H5Awrite failed");
-   }
+    herr_t ret_value = H5Awrite(id, mem_type.getId(), buf);
+    if(ret_value < 0)
+    {
+        throw AttributeIException("Attribute::write", "H5Awrite failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -140,13 +140,13 @@ void Attribute::write(const DataType& mem_type, const H5std_string& strg) const
 ///\exception   H5::AttributeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void Attribute::read( const DataType& mem_type, void *buf ) const
+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("Attribute::read", "H5Aread failed");
-   }
+    herr_t ret_value = H5Aread(id, mem_type.getId(), buf);
+    if(ret_value < 0)
+    {
+        throw AttributeIException("Attribute::read", "H5Aread failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -202,7 +202,7 @@ size_t Attribute::getInMemDataSize() const
 
     // Get the data type of this attribute
     hid_t mem_type_id = H5Aget_type(id);
-    if( mem_type_id < 0 )
+    if(mem_type_id < 0)
     {
         throw AttributeIException(func, "H5Aget_type failed");
     }
@@ -263,20 +263,20 @@ size_t Attribute::getInMemDataSize() const
 //--------------------------------------------------------------------------
 DataSpace Attribute::getSpace() const
 {
-   // Calls C function H5Aget_space to get the id of the dataspace
-   hid_t dataspace_id = H5Aget_space( id );
+    // 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 )
-   {
+    // If the dataspace id is valid, create and return the DataSpace object
+    if(dataspace_id > 0)
+    {
         DataSpace dataspace;
         f_DataSpace_setId(&dataspace, dataspace_id);
         return(dataspace);
-   }
-   else
-   {
-      throw AttributeIException("Attribute::getSpace", "H5Aget_space failed");
-   }
+    }
+    else
+    {
+        throw AttributeIException("Attribute::getSpace", "H5Aget_space failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -288,12 +288,12 @@ DataSpace Attribute::getSpace() const
 //--------------------------------------------------------------------------
 H5std_string Attribute::getFileName() const
 {
-   try {
-      return(p_get_file_name());
-   }
-   catch (IdComponentException& E) {
-      throw FileIException("Attribute::getFileName", E.getDetailMsg());
-   }
+    try {
+        return(p_get_file_name());
+    }
+    catch (IdComponentException& E) {
+        throw FileIException("Attribute::getFileName", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -463,9 +463,9 @@ ssize_t Attribute::getName(H5std_string& attr_name, size_t len) const
 //              Removed from documentation. -BMR, 2016/03/07 1.8.17 and 1.10.0
 //              Removed from code. -BMR, 2016/08/11 1.8.18 and 1.10.1
 //--------------------------------------------------------------------------
-//ssize_t Attribute::getName( size_t len, H5std_string& attr_name ) const
+//ssize_t Attribute::getName(size_t len, H5std_string& attr_name) const
 //{
-//    return (getName(attr_name, len));
+//  return (getName(attr_name, len));
 //}
 
 //--------------------------------------------------------------------------
@@ -479,8 +479,8 @@ ssize_t Attribute::getName(H5std_string& attr_name, size_t len) const
 //--------------------------------------------------------------------------
 hsize_t Attribute::getStorageSize() const
 {
-   hsize_t storage_size = H5Aget_storage_size(id);
-   return (storage_size);
+    hsize_t storage_size = H5Aget_storage_size(id);
+    return (storage_size);
 }
 
 //--------------------------------------------------------------------------
@@ -501,11 +501,11 @@ hsize_t Attribute::getStorageSize() const
 //--------------------------------------------------------------------------
 void Attribute::flush(H5F_scope_t scope) const
 {
-   herr_t ret_value = H5Fflush(getId(), scope);
-   if( ret_value < 0 )
-   {
-      throw AttributeIException("Attribute::flush", "H5Fflush failed");
-   }
+    herr_t ret_value = H5Fflush(getId(), scope);
+    if(ret_value < 0)
+    {
+        throw AttributeIException("Attribute::flush", "H5Fflush failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -521,7 +521,7 @@ void Attribute::flush(H5F_scope_t scope) const
 //--------------------------------------------------------------------------
 hid_t Attribute::getId() const
 {
-   return(id);
+    return(id);
 }
 
 //--------------------------------------------------------------------------
@@ -535,13 +535,13 @@ hid_t Attribute::getId() const
 //--------------------------------------------------------------------------
 hid_t Attribute::p_get_type() const
 {
-   hid_t type_id = H5Aget_type( id );
-   if( type_id > 0 )
-      return( type_id );
-   else
-   {
-      throw AttributeIException("", "H5Aget_type failed");
-   }
+    hid_t type_id = H5Aget_type(id);
+    if(type_id > 0)
+        return(type_id);
+    else
+    {
+        throw AttributeIException("", "H5Aget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -568,7 +568,7 @@ void Attribute::p_read_fixed_len(const DataType& mem_type, H5std_string& strg) c
     {
         char *strg_C = new char[attr_size+1];
         herr_t ret_value = H5Aread(id, mem_type.getId(), strg_C);
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             delete []strg_C;    // de-allocate for fixed-len string
             throw AttributeIException("Attribute::read", "H5Aread failed");
@@ -600,7 +600,7 @@ void Attribute::p_read_variable_len(const DataType& mem_type, H5std_string& strg
     // Read attribute, no allocation for variable-len string; C library will
     herr_t ret_value = H5Aread(id, mem_type.getId(), &strg_C);
 
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw AttributeIException("Attribute::read", "H5Aread failed");
     }
@@ -632,8 +632,8 @@ void Attribute::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw AttributeIException("Attribute::p_setId", close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -649,7 +649,7 @@ void Attribute::close()
     if (p_valid_id(id))
     {
         herr_t ret_value = H5Aclose(id);
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             throw AttributeIException("Attribute::close", "H5Aclose failed");
         }
diff --git a/c++/src/H5Attribute.h b/c++/src/H5Attribute.h
index 4f933e9..e61da01 100644
--- a/c++/src/H5Attribute.h
+++ b/c++/src/H5Attribute.h
@@ -32,13 +32,13 @@ class H5_DLLCPP Attribute : public AbstractDs, public IdComponent {
    public:
 
         // Copy constructor: makes a copy of an existing Attribute object.
-        Attribute( const Attribute& original );
+        Attribute(const Attribute& original);
 
         // Default constructor
         Attribute();
 
         // Creates a copy of an existing attribute using the attribute id
-        Attribute( const hid_t attr_id );
+        Attribute(const hid_t attr_id);
 
         // Closes this attribute.
         virtual void close();
@@ -53,7 +53,7 @@ class H5_DLLCPP Attribute : public AbstractDs, public IdComponent {
         ssize_t getName(H5std_string& attr_name, size_t len = 0) const;
         // The overloaded function below is replaced by the one above and it
         // is kept for backward compatibility purpose.
-        ssize_t getName( size_t buf_size, H5std_string& attr_name ) const;
+        ssize_t getName(size_t buf_size, H5std_string& attr_name) const;
 
         // Gets a copy of the dataspace for this attribute.
         virtual DataSpace getSpace() const;
@@ -65,16 +65,16 @@ class H5_DLLCPP Attribute : public AbstractDs, public IdComponent {
         virtual size_t getInMemDataSize() const;
 
         // Reads data from this attribute.
-        void read( const DataType& mem_type, void *buf ) const;
-        void read( const DataType& mem_type, H5std_string& strg ) const;
+        void read(const DataType& mem_type, void *buf) const;
+        void read(const DataType& mem_type, H5std_string& strg) const;
 
         // Writes data to this attribute.
-        void write(const DataType& mem_type, const void *buf ) const;
-        void write(const DataType& mem_type, const H5std_string& strg ) const;
+        void write(const DataType& mem_type, const void *buf) const;
+        void write(const DataType& mem_type, const H5std_string& strg) const;
 
         // Flushes all buffers associated with the file specified by this
         // attribute to disk.
-        void flush( H5F_scope_t scope ) const;
+        void flush(H5F_scope_t scope) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("Attribute"); }
diff --git a/c++/src/H5CommonFG.cpp b/c++/src/H5CommonFG.cpp
index e1c4818..10f6c58 100644
--- a/c++/src/H5CommonFG.cpp
+++ b/c++/src/H5CommonFG.cpp
@@ -65,7 +65,7 @@ namespace H5 {
 ///             then a default size is chosen.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-     Group CommonFG::createGroup( const char* name, size_t size_hint ) const
+Group CommonFG::createGroup(const char* name, size_t size_hint) const
 {
     // Group creation property list for size hint
     hid_t gcpl_id = 0;
@@ -73,33 +73,33 @@ namespace H5 {
     // Set the local heap size hint
     if (size_hint > 0)
     {
-       // If the creation of the property list failed, throw an exception
-       if ((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0)
-          throwException("createGroup", "H5Pcreate failed");
-
-       if (H5Pset_local_heap_size_hint(gcpl_id, size_hint) < 0) {
-          H5Pclose(gcpl_id);
-          throwException("createGroup", "H5Pset_local_heap_size_hint failed");
-       }
+        // If the creation of the property list failed, throw an exception
+        if ((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0)
+            throwException("createGroup", "H5Pcreate failed");
+
+        if (H5Pset_local_heap_size_hint(gcpl_id, size_hint) < 0) {
+            H5Pclose(gcpl_id);
+            throwException("createGroup", "H5Pset_local_heap_size_hint failed");
+        }
     }
 
-   // Call C routine H5Gcreate2 to create the named group, giving the
-   // location id which can be a file id or a group id
-   hid_t group_id = H5Gcreate2( getLocId(), name, H5P_DEFAULT, gcpl_id, H5P_DEFAULT );
+    // Call C routine H5Gcreate2 to create the named group, giving the
+    // location id which can be a file id or a group id
+    hid_t group_id = H5Gcreate2(getLocId(), name, H5P_DEFAULT, gcpl_id, H5P_DEFAULT);
 
-   // Close the group creation property list, if necessary
-   if(gcpl_id > 0)
-       H5Pclose(gcpl_id);
+    // Close the group creation property list, if necessary
+    if(gcpl_id > 0)
+        H5Pclose(gcpl_id);
 
-   // If the creation of the group failed, throw an exception
-   if( group_id < 0 )
-      throwException("createGroup", "H5Gcreate2 failed");
+    // If the creation of the group failed, throw an exception
+    if(group_id < 0)
+        throwException("createGroup", "H5Gcreate2 failed");
 
-   // No failure, create and return the Group object
-   Group group;
+    // No failure, create and return the Group object
+    Group group;
     CommonFG *ptr = &group;
     ptr->p_setId(group_id);
-   return( group );
+    return(group);
 }
 
 //--------------------------------------------------------------------------
@@ -109,9 +109,9 @@ namespace H5 {
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Group CommonFG::createGroup( const H5std_string& name, size_t size_hint ) const
+Group CommonFG::createGroup(const H5std_string& name, size_t size_hint) const
 {
-   return( createGroup( name.c_str(), size_hint ));
+    return(createGroup(name.c_str(), size_hint));
 }
 
 //--------------------------------------------------------------------------
@@ -123,21 +123,21 @@ Group CommonFG::createGroup( const H5std_string& name, size_t size_hint ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Group CommonFG::openGroup( const char* name ) const
+Group CommonFG::openGroup(const char* name) const
 {
-   // Call C routine H5Gopen2 to open the named group, giving the
-   // location id which can be a file id or a group id
-   hid_t group_id = H5Gopen2( getLocId(), name, H5P_DEFAULT );
+    // Call C routine H5Gopen2 to open the named group, giving the
+    // location id which can be a file id or a group id
+    hid_t group_id = H5Gopen2(getLocId(), name, H5P_DEFAULT);
 
-   // If the opening of the group failed, throw an exception
-   if( group_id < 0 )
-      throwException("openGroup", "H5Gopen2 failed");
+    // If the opening of the group failed, throw an exception
+    if(group_id < 0)
+        throwException("openGroup", "H5Gopen2 failed");
 
-   // No failure, create and return the Group object
-   Group group;
+    // No failure, create and return the Group object
+    Group group;
     CommonFG *ptr = &group;
     ptr->p_setId(group_id);
-   return( group );
+    return(group);
 }
 
 //--------------------------------------------------------------------------
@@ -147,9 +147,9 @@ Group CommonFG::openGroup( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Group CommonFG::openGroup( const H5std_string& name ) const
+Group CommonFG::openGroup(const H5std_string& name) const
 {
-   return( openGroup( name.c_str() ));
+    return(openGroup(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -163,24 +163,24 @@ Group CommonFG::openGroup( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSet CommonFG::createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist ) const
+DataSet CommonFG::createDataSet(const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist) const
 {
-   // 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 H5Dcreate2 to create the named dataset
-   hid_t dataset_id = H5Dcreate2( getLocId(), name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT );
-
-   // If the creation of the dataset failed, throw an exception
-   if( dataset_id < 0 )
-      throwException("createDataSet", "H5Dcreate2 failed");
-
-   // No failure, create and return the DataSet object
-   DataSet dataset;
-   f_DataSet_setId(&dataset, dataset_id);
-   return( dataset );
+    // 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 H5Dcreate2 to create the named dataset
+    hid_t dataset_id = H5Dcreate2(getLocId(), name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT);
+
+    // If the creation of the dataset failed, throw an exception
+    if(dataset_id < 0)
+        throwException("createDataSet", "H5Dcreate2 failed");
+
+    // No failure, create and return the DataSet object
+    DataSet dataset;
+    f_DataSet_setId(&dataset, dataset_id);
+    return(dataset);
 }
 
 //--------------------------------------------------------------------------
@@ -190,9 +190,9 @@ DataSet CommonFG::createDataSet( const char* name, const DataType& data_type, co
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSet CommonFG::createDataSet( const H5std_string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist ) const
+DataSet CommonFG::createDataSet(const H5std_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 ));
+    return(createDataSet(name.c_str(), data_type, data_space, create_plist));
 }
 
 //--------------------------------------------------------------------------
@@ -203,20 +203,20 @@ DataSet CommonFG::createDataSet( const H5std_string& name, const DataType& data_
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSet CommonFG::openDataSet( const char* name ) const
+DataSet CommonFG::openDataSet(const char* name) const
 {
-   // Call C function H5Dopen2 to open the specified dataset, giving
-   // the location id and the dataset's name
-   hid_t dataset_id = H5Dopen2( getLocId(), name, H5P_DEFAULT );
-
-   // If the dataset's opening failed, throw an exception
-   if(dataset_id < 0)
-      throwException("openDataSet", "H5Dopen2 failed");
-
-   // No failure, create and return the DataSet object
-   DataSet dataset;
-   f_DataSet_setId(&dataset, dataset_id);
-   return( dataset );
+    // Call C function H5Dopen2 to open the specified dataset, giving
+    // the location id and the dataset's name
+    hid_t dataset_id = H5Dopen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the dataset's opening failed, throw an exception
+    if(dataset_id < 0)
+        throwException("openDataSet", "H5Dopen2 failed");
+
+    // No failure, create and return the DataSet object
+    DataSet dataset;
+    f_DataSet_setId(&dataset, dataset_id);
+    return(dataset);
 }
 
 //--------------------------------------------------------------------------
@@ -226,9 +226,9 @@ DataSet CommonFG::openDataSet( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSet CommonFG::openDataSet( const H5std_string& name ) const
+DataSet CommonFG::openDataSet(const H5std_string& name) const
 {
-   return( openDataSet( name.c_str() ));
+    return(openDataSet(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -253,17 +253,17 @@ DataSet CommonFG::openDataSet( const H5std_string& name ) const
 // Modification
 //      2007: QAK modified to use H5L APIs - BMR
 //--------------------------------------------------------------------------
-void CommonFG::link( H5L_type_t link_type, const char* curr_name, const char* new_name ) const
+void CommonFG::link(H5L_type_t link_type, const char* curr_name, const char* new_name) const
 {
     herr_t ret_value = -1;
 
     switch(link_type) {
         case H5L_TYPE_HARD:
-            ret_value = H5Lcreate_hard( getLocId(), curr_name, H5L_SAME_LOC, new_name, H5P_DEFAULT, H5P_DEFAULT );
+            ret_value = H5Lcreate_hard(getLocId(), curr_name, H5L_SAME_LOC, new_name, H5P_DEFAULT, H5P_DEFAULT);
             break;
 
         case H5L_TYPE_SOFT:
-            ret_value = H5Lcreate_soft( curr_name, getLocId(), new_name, H5P_DEFAULT, H5P_DEFAULT );
+            ret_value = H5Lcreate_soft(curr_name, getLocId(), new_name, H5P_DEFAULT, H5P_DEFAULT);
             break;
 
         case H5L_TYPE_ERROR:
@@ -274,8 +274,8 @@ void CommonFG::link( H5L_type_t link_type, const char* curr_name, const char* ne
             break;
     } /* end switch */
 
-   if( ret_value < 0 )
-      throwException("link", "creating link failed");
+    if(ret_value < 0)
+        throwException("link", "creating link failed");
 }
 
 //--------------------------------------------------------------------------
@@ -285,9 +285,9 @@ void CommonFG::link( H5L_type_t link_type, const char* curr_name, const char* ne
 ///             \c H5std_string for \a curr_name and \a new_name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::link( H5L_type_t link_type, const H5std_string& curr_name, const H5std_string& new_name ) const
+void CommonFG::link(H5L_type_t link_type, const H5std_string& curr_name, const H5std_string& new_name) const
 {
-   link( link_type, curr_name.c_str(), new_name.c_str() );
+    link(link_type, curr_name.c_str(), new_name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -299,11 +299,11 @@ void CommonFG::link( H5L_type_t link_type, const H5std_string& curr_name, const
 // Modification
 //      2007: QAK modified to use H5L APIs - BMR
 //--------------------------------------------------------------------------
-void CommonFG::unlink( const char* name ) const
+void CommonFG::unlink(const char* name) const
 {
-   herr_t ret_value = H5Ldelete( getLocId(), name, H5P_DEFAULT );
-   if( ret_value < 0 )
-      throwException("unlink", "H5Ldelete failed");
+    herr_t ret_value = H5Ldelete(getLocId(), name, H5P_DEFAULT);
+    if(ret_value < 0)
+        throwException("unlink", "H5Ldelete failed");
 }
 
 //--------------------------------------------------------------------------
@@ -313,9 +313,9 @@ void CommonFG::unlink( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::unlink( const H5std_string& name ) const
+void CommonFG::unlink(const H5std_string& name) const
 {
-   unlink( name.c_str() );
+    unlink(name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -333,11 +333,11 @@ void CommonFG::unlink( const H5std_string& name ) const
 // Modification
 //      2007: QAK modified to use H5L APIs - BMR
 //--------------------------------------------------------------------------
-void CommonFG::move( const char* src, const char* dst ) const
+void CommonFG::move(const char* src, const char* dst) const
 {
-   herr_t ret_value = H5Lmove( getLocId(), src, H5L_SAME_LOC, dst, H5P_DEFAULT, H5P_DEFAULT );
-   if( ret_value < 0 )
-      throwException("move", "H5Lmove failed");
+    herr_t ret_value = H5Lmove(getLocId(), src, H5L_SAME_LOC, dst, H5P_DEFAULT, H5P_DEFAULT);
+    if(ret_value < 0)
+        throwException("move", "H5Lmove failed");
 }
 
 //--------------------------------------------------------------------------
@@ -347,9 +347,9 @@ void CommonFG::move( const char* src, const char* dst ) const
 ///             \c H5std_string for \a src and \a dst.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::move( const H5std_string& src, const H5std_string& dst ) const
+void CommonFG::move(const H5std_string& src, const H5std_string& dst) const
 {
-   move( src.c_str(), dst.c_str() );
+    move(src.c_str(), dst.c_str());
 }
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
@@ -366,11 +366,11 @@ void CommonFG::move( const H5std_string& src, const H5std_string& dst ) const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5G.html#Group-GetObjinfo
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const
+void CommonFG::getObjinfo(const char* name, hbool_t follow_link, H5G_stat_t& statbuf) const
 {
-   herr_t ret_value = H5Gget_objinfo( getLocId(), name, follow_link, &statbuf );
-   if( ret_value < 0 )
-      throwException("getObjinfo", "H5Gget_objinfo failed");
+    herr_t ret_value = H5Gget_objinfo(getLocId(), name, follow_link, &statbuf);
+    if(ret_value < 0)
+        throwException("getObjinfo", "H5Gget_objinfo failed");
 }
 
 //--------------------------------------------------------------------------
@@ -380,9 +380,9 @@ void CommonFG::getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& st
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::getObjinfo( const H5std_string& name, hbool_t follow_link, H5G_stat_t& statbuf ) const
+void CommonFG::getObjinfo(const H5std_string& name, hbool_t follow_link, H5G_stat_t& statbuf) const
 {
-   getObjinfo( name.c_str(), follow_link, statbuf );
+    getObjinfo(name.c_str(), follow_link, statbuf);
 }
 
 //--------------------------------------------------------------------------
@@ -393,11 +393,11 @@ void CommonFG::getObjinfo( const H5std_string& name, hbool_t follow_link, H5G_st
 // Programmer   Binh-Minh Ribler - Nov, 2005
 // Note: need to modify to use H5Oget_info and H5Lget_info - BMR
 //--------------------------------------------------------------------------
-void CommonFG::getObjinfo( const char* name, H5G_stat_t& statbuf ) const
+void CommonFG::getObjinfo(const char* name, H5G_stat_t& statbuf) const
 {
-   herr_t ret_value = H5Gget_objinfo( getLocId(), name, 0, &statbuf );
-   if( ret_value < 0 )
-      throwException("getObjinfo", "H5Gget_objinfo failed");
+    herr_t ret_value = H5Gget_objinfo(getLocId(), name, 0, &statbuf);
+    if(ret_value < 0)
+        throwException("getObjinfo", "H5Gget_objinfo failed");
 }
 
 //--------------------------------------------------------------------------
@@ -407,9 +407,9 @@ void CommonFG::getObjinfo( const char* name, H5G_stat_t& statbuf ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - Nov, 2005
 //--------------------------------------------------------------------------
-void CommonFG::getObjinfo( const H5std_string& name, H5G_stat_t& statbuf ) const
+void CommonFG::getObjinfo(const H5std_string& name, H5G_stat_t& statbuf) const
 {
-   getObjinfo( name.c_str(), statbuf );
+    getObjinfo(name.c_str(), statbuf);
 }
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
 
@@ -422,7 +422,7 @@ void CommonFG::getObjinfo( const H5std_string& name, H5G_stat_t& statbuf ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string CommonFG::getLinkval( const char* name, size_t size ) const
+H5std_string CommonFG::getLinkval(const char* name, size_t size) const
 {
     H5L_info_t linkinfo;
     char *value_C;      // value in C string
@@ -434,7 +434,7 @@ H5std_string CommonFG::getLinkval( const char* name, size_t size ) const
     if (size == 0)
     {
         ret_value = H5Lget_info(getLocId(), name, &linkinfo, H5P_DEFAULT);
-        if( ret_value < 0 )
+        if(ret_value < 0)
             throwException("getLinkval", "H5Lget_info to find buffer size failed");
 
         val_size = linkinfo.u.val_size;
@@ -447,7 +447,7 @@ H5std_string CommonFG::getLinkval( const char* name, size_t size ) const
         HDmemset(value_C, 0, val_size+1); // clear buffer
 
         ret_value = H5Lget_val(getLocId(), name, value_C, val_size, H5P_DEFAULT);
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             delete []value_C;
             throwException("getLinkval", "H5Lget_val failed");
@@ -466,9 +466,9 @@ H5std_string CommonFG::getLinkval( const char* name, size_t size ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string CommonFG::getLinkval( const H5std_string& name, size_t size ) const
+H5std_string CommonFG::getLinkval(const H5std_string& name, size_t size) const
 {
-   return( getLinkval( name.c_str(), size ));
+    return(getLinkval(name.c_str(), size));
 }
 
 //--------------------------------------------------------------------------
@@ -482,18 +482,18 @@ H5std_string CommonFG::getLinkval( const H5std_string& name, size_t size ) const
 // Modification
 //              Replaced the version without const parameter - Apr, 2014
 //--------------------------------------------------------------------------
-void CommonFG::mount(const char* name, const H5File& child, const PropList& plist ) const
+void CommonFG::mount(const char* name, const H5File& child, const PropList& plist) const
 {
-   // Obtain identifiers for C API
-   hid_t plist_id = plist.getId();
-   hid_t child_id = child.getId();
+    // Obtain identifiers for C API
+    hid_t plist_id = plist.getId();
+    hid_t child_id = child.getId();
 
-   // Call C routine H5Fmount to do the mouting
-   herr_t ret_value = H5Fmount( getLocId(), name, child_id, plist_id );
+    // Call C routine H5Fmount to do the mouting
+    herr_t ret_value = H5Fmount(getLocId(), name, child_id, plist_id);
 
-   // Raise exception if H5Fmount returns negative value
-   if( ret_value < 0 )
-      throwException("mount", "H5Fmount failed");
+    // Raise exception if H5Fmount returns negative value
+    if(ret_value < 0)
+        throwException("mount", "H5Fmount failed");
 }
 
 //--------------------------------------------------------------------------
@@ -526,7 +526,7 @@ void CommonFG::mount(const char* name, const H5File& child, const PropList& plis
 //--------------------------------------------------------------------------
 void CommonFG::mount(const H5std_string& name, const H5File& child, const PropList& plist) const
 {
-   mount(name.c_str(), child, plist);
+    mount(name.c_str(), child, plist);
 }
 
 //--------------------------------------------------------------------------
@@ -552,14 +552,14 @@ void CommonFG::mount(const H5std_string& name, const H5File& child, const PropLi
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::unmount( const char* name ) const
+void CommonFG::unmount(const char* name) const
 {
-   // Call C routine H5Fmount to do the mouting
-   herr_t ret_value = H5Funmount( getLocId(), name );
+    // Call C routine H5Fmount to do the mouting
+    herr_t ret_value = H5Funmount(getLocId(), name);
 
-   // Raise exception if H5Funmount returns negative value
-   if( ret_value < 0 )
-      throwException("unmount", "H5Funmount failed");
+    // Raise exception if H5Funmount returns negative value
+    if(ret_value < 0)
+        throwException("unmount", "H5Funmount failed");
 }
 
 //--------------------------------------------------------------------------
@@ -569,9 +569,9 @@ void CommonFG::unmount( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CommonFG::unmount( const H5std_string& name ) const
+void CommonFG::unmount(const H5std_string& name) const
 {
-   unmount( name.c_str() );
+    unmount(name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -582,20 +582,20 @@ void CommonFG::unmount( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataType CommonFG::openDataType( const char* name ) const
+DataType CommonFG::openDataType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openDataType", "H5Topen2 failed");
-
-   // No failure, create and return the DataType object
-   DataType data_type;
-   f_DataType_setId(&data_type, type_id);
-   return(data_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openDataType", "H5Topen2 failed");
+
+    // No failure, create and return the DataType object
+    DataType data_type;
+    f_DataType_setId(&data_type, type_id);
+    return(data_type);
 }
 
 //--------------------------------------------------------------------------
@@ -605,9 +605,9 @@ DataType CommonFG::openDataType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataType CommonFG::openDataType( const H5std_string& name ) const
+DataType CommonFG::openDataType(const H5std_string& name) const
 {
-   return( openDataType( name.c_str()) );
+    return(openDataType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -618,20 +618,20 @@ DataType CommonFG::openDataType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-ArrayType CommonFG::openArrayType( const char* name ) const
+ArrayType CommonFG::openArrayType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openArrayType", "H5Topen2 failed");
-
-   // No failure, create and return the ArrayType object
-   ArrayType array_type;
-   f_DataType_setId(&array_type, type_id);
-   return(array_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openArrayType", "H5Topen2 failed");
+
+    // No failure, create and return the ArrayType object
+    ArrayType array_type;
+    f_DataType_setId(&array_type, type_id);
+    return(array_type);
 }
 
 //--------------------------------------------------------------------------
@@ -641,9 +641,9 @@ ArrayType CommonFG::openArrayType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-ArrayType CommonFG::openArrayType( const H5std_string& name ) const
+ArrayType CommonFG::openArrayType(const H5std_string& name) const
 {
-   return( openArrayType( name.c_str()) );
+    return(openArrayType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -654,20 +654,20 @@ ArrayType CommonFG::openArrayType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType CommonFG::openCompType( const char* name ) const
+CompType CommonFG::openCompType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openCompType", "H5Topen2 failed");
-
-   // No failure, create and return the CompType object
-   CompType comp_type;
-   f_DataType_setId(&comp_type, type_id);
-   return(comp_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openCompType", "H5Topen2 failed");
+
+    // No failure, create and return the CompType object
+    CompType comp_type;
+    f_DataType_setId(&comp_type, type_id);
+    return(comp_type);
 }
 
 //--------------------------------------------------------------------------
@@ -677,9 +677,9 @@ CompType CommonFG::openCompType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType CommonFG::openCompType( const H5std_string& name ) const
+CompType CommonFG::openCompType(const H5std_string& name) const
 {
-   return( openCompType( name.c_str()) );
+    return(openCompType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -690,20 +690,20 @@ CompType CommonFG::openCompType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType CommonFG::openEnumType( const char* name ) const
+EnumType CommonFG::openEnumType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openEnumType", "H5Topen2 failed");
-
-   // No failure, create and return the EnumType object
-   EnumType enum_type;
-   f_DataType_setId(&enum_type, type_id);
-   return(enum_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openEnumType", "H5Topen2 failed");
+
+    // No failure, create and return the EnumType object
+    EnumType enum_type;
+    f_DataType_setId(&enum_type, type_id);
+    return(enum_type);
 }
 
 //--------------------------------------------------------------------------
@@ -713,9 +713,9 @@ EnumType CommonFG::openEnumType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType CommonFG::openEnumType( const H5std_string& name ) const
+EnumType CommonFG::openEnumType(const H5std_string& name) const
 {
-   return( openEnumType( name.c_str()) );
+    return(openEnumType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -726,20 +726,20 @@ EnumType CommonFG::openEnumType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType CommonFG::openIntType( const char* name ) const
+IntType CommonFG::openIntType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openIntType", "H5Topen2 failed");
-
-   // No failure, create and return the IntType object
-   IntType int_type;
-   f_DataType_setId(&int_type, type_id);
-   return(int_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openIntType", "H5Topen2 failed");
+
+    // No failure, create and return the IntType object
+    IntType int_type;
+    f_DataType_setId(&int_type, type_id);
+    return(int_type);
 }
 
 //--------------------------------------------------------------------------
@@ -749,9 +749,9 @@ IntType CommonFG::openIntType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType CommonFG::openIntType( const H5std_string& name ) const
+IntType CommonFG::openIntType(const H5std_string& name) const
 {
-   return( openIntType( name.c_str()) );
+    return(openIntType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -762,20 +762,20 @@ IntType CommonFG::openIntType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType CommonFG::openFloatType( const char* name ) const
+FloatType CommonFG::openFloatType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openFloatType", "H5Topen2 failed");
-
-   // No failure, create and return the FloatType object
-   FloatType float_type;
-   f_DataType_setId(&float_type, type_id);
-   return(float_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openFloatType", "H5Topen2 failed");
+
+    // No failure, create and return the FloatType object
+    FloatType float_type;
+    f_DataType_setId(&float_type, type_id);
+    return(float_type);
 }
 
 //--------------------------------------------------------------------------
@@ -785,9 +785,9 @@ FloatType CommonFG::openFloatType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType CommonFG::openFloatType( const H5std_string& name ) const
+FloatType CommonFG::openFloatType(const H5std_string& name) const
 {
-   return( openFloatType( name.c_str()) );
+    return(openFloatType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -798,20 +798,20 @@ FloatType CommonFG::openFloatType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType CommonFG::openStrType( const char* name ) const
+StrType CommonFG::openStrType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openStrType", "H5Topen2 failed");
-
-   // No failure, create and return the StrType object
-   StrType str_type;
-   f_DataType_setId(&str_type, type_id);
-   return(str_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openStrType", "H5Topen2 failed");
+
+    // No failure, create and return the StrType object
+    StrType str_type;
+    f_DataType_setId(&str_type, type_id);
+    return(str_type);
 }
 
 //--------------------------------------------------------------------------
@@ -821,9 +821,9 @@ StrType CommonFG::openStrType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType CommonFG::openStrType( const H5std_string& name ) const
+StrType CommonFG::openStrType(const H5std_string& name) const
 {
-   return( openStrType( name.c_str()) );
+    return(openStrType(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -834,20 +834,20 @@ StrType CommonFG::openStrType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-VarLenType CommonFG::openVarLenType( const char* name ) const
+VarLenType CommonFG::openVarLenType(const char* name) const
 {
-   // Call C function H5Topen2 to open the named datatype in this group,
-   // given either the file or group id
-   hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
-
-   // If the datatype's opening failed, throw an exception
-   if( type_id < 0 )
-      throwException("openVarLenType", "H5Topen2 failed");
-
-   // No failure, create and return the VarLenType object
-   VarLenType varlen_type;
-   f_DataType_setId(&varlen_type, type_id);
-   return(varlen_type);
+    // Call C function H5Topen2 to open the named datatype in this group,
+    // given either the file or group id
+    hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
+
+    // If the datatype's opening failed, throw an exception
+    if(type_id < 0)
+        throwException("openVarLenType", "H5Topen2 failed");
+
+    // No failure, create and return the VarLenType object
+    VarLenType varlen_type;
+    f_DataType_setId(&varlen_type, type_id);
+    return(varlen_type);
 }
 
 //--------------------------------------------------------------------------
@@ -857,9 +857,9 @@ VarLenType CommonFG::openVarLenType( const char* name ) const
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-VarLenType CommonFG::openVarLenType( const H5std_string& name ) const
+VarLenType CommonFG::openVarLenType(const H5std_string& name) const
 {
-   return( openVarLenType( name.c_str()) );
+    return(openVarLenType(name.c_str()));
 }
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
@@ -876,14 +876,14 @@ VarLenType CommonFG::openVarLenType( const H5std_string& name ) const
 ///\exception   H5::FileIException or H5::GroupIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int CommonFG::iterateElems( const char* name, int *idx, H5G_iterate_t op , void* op_data )
+int CommonFG::iterateElems(const char* name, int *idx, H5G_iterate_t op , void* op_data)
 {
-   int ret_value = H5Giterate( getLocId(), name, idx, op, op_data );
-   if( ret_value < 0 )
-   {
-      throwException("iterateElems", "H5Giterate failed");
-   }
-   return( ret_value );
+    int ret_value = H5Giterate(getLocId(), name, idx, op, op_data);
+    if(ret_value < 0)
+    {
+        throwException("iterateElems", "H5Giterate failed");
+    }
+    return(ret_value);
 }
 
 //--------------------------------------------------------------------------
@@ -893,9 +893,9 @@ int CommonFG::iterateElems( const char* name, int *idx, H5G_iterate_t op , void*
 ///             \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int CommonFG::iterateElems( const H5std_string& name, int *idx, H5G_iterate_t op , void* op_data )
+int CommonFG::iterateElems(const H5std_string& name, int *idx, H5G_iterate_t op , void* op_data)
 {
-   return( iterateElems( name.c_str(), idx, op, op_data ));
+    return(iterateElems(name.c_str(), idx, op, op_data));
 }
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
 
@@ -908,12 +908,12 @@ int CommonFG::iterateElems( const H5std_string& name, int *idx, H5G_iterate_t op
 //--------------------------------------------------------------------------
 hsize_t CommonFG::getNumObjs() const
 {
-   H5G_info_t           ginfo;                  /* Group information */
+    H5G_info_t           ginfo;                  /* Group information */
 
-   herr_t ret_value = H5Gget_info(getLocId(), &ginfo);
-   if(ret_value < 0)
-      throwException("getNumObjs", "H5Gget_info failed");
-   return (ginfo.nlinks);
+    herr_t ret_value = H5Gget_info(getLocId(), &ginfo);
+    if(ret_value < 0)
+        throwException("getNumObjs", "H5Gget_info failed");
+    return (ginfo.nlinks);
 }
 
 //--------------------------------------------------------------------------
@@ -936,7 +936,7 @@ H5std_string CommonFG::getObjnameByIdx(hsize_t idx) const
     // call H5Lget_name_by_idx with name as NULL to get its length
     ssize_t name_len = H5Lget_name_by_idx(getLocId(), ".", H5_INDEX_NAME, H5_ITER_INC, idx, NULL, 0, H5P_DEFAULT);
     if(name_len < 0)
-      throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
+        throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
 
     // now, allocate C buffer to get the name
     char* name_C = new char[name_len+1];
@@ -975,11 +975,11 @@ H5std_string CommonFG::getObjnameByIdx(hsize_t idx) const
 //--------------------------------------------------------------------------
 ssize_t CommonFG::getObjnameByIdx(hsize_t idx, char* name, size_t size) const
 {
-   ssize_t name_len = H5Lget_name_by_idx(getLocId(), ".", H5_INDEX_NAME, H5_ITER_INC, idx, name, size, H5P_DEFAULT);
-   if(name_len < 0)
-      throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
+    ssize_t name_len = H5Lget_name_by_idx(getLocId(), ".", H5_INDEX_NAME, H5_ITER_INC, idx, name, size, H5P_DEFAULT);
+    if(name_len < 0)
+        throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
 
-   return (name_len);
+    return (name_len);
 }
 
 //--------------------------------------------------------------------------
@@ -991,21 +991,21 @@ ssize_t CommonFG::getObjnameByIdx(hsize_t idx, char* name, size_t size) const
 //--------------------------------------------------------------------------
 ssize_t CommonFG::getObjnameByIdx(hsize_t idx, H5std_string& name, size_t size) const
 {
-   char* name_C = new char[size+1]; // temporary C-string for object name
-   HDmemset(name_C, 0, size+1); // clear buffer
+    char* name_C = new char[size+1]; // temporary C-string for object name
+    HDmemset(name_C, 0, size+1); // clear buffer
 
-   // call overloaded function to get the name
-   ssize_t name_len = getObjnameByIdx(idx, name_C, size+1);
-   if(name_len < 0)
-   {
+    // call overloaded function to get the name
+    ssize_t name_len = getObjnameByIdx(idx, name_C, size+1);
+    if(name_len < 0)
+    {
       delete []name_C;
-      throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
-   }
+        throwException("getObjnameByIdx", "H5Lget_name_by_idx failed");
+    }
 
-   // clean up and return the string
-   name = H5std_string(name_C);
-   delete []name_C;
-   return (name_len);
+    // clean up and return the string
+    name = H5std_string(name_C);
+    delete []name_C;
+    return (name_len);
 }
 
 //--------------------------------------------------------------------------
@@ -1040,7 +1040,7 @@ H5O_type_t CommonFG::childObjType(const char* objname) const
     // Return a valid type or throw an exception for unknown type
     else
       switch (objinfo.type)
-      {
+        {
         case H5O_TYPE_GROUP:
         case H5O_TYPE_DATASET:
         case H5O_TYPE_NAMED_DATATYPE:
@@ -1050,7 +1050,7 @@ H5O_type_t CommonFG::childObjType(const char* objname) const
         case H5O_TYPE_NTYPES:
         default:
             throwException("childObjType", "Unknown type of object");
-      }
+        }
     return(objtype);
 }
 
@@ -1115,7 +1115,7 @@ H5O_type_t CommonFG::childObjType(hsize_t index, H5_index_t index_type, H5_iter_
     // Return a valid type or throw an exception for unknown type
     else
       switch (objinfo.type)
-      {
+        {
         case H5O_TYPE_GROUP:
         case H5O_TYPE_DATASET:
         case H5O_TYPE_NAMED_DATATYPE:
@@ -1125,7 +1125,7 @@ H5O_type_t CommonFG::childObjType(hsize_t index, H5_index_t index_type, H5_iter_
         case H5O_TYPE_NTYPES:
         default:
             throwException("childObjType", "Unknown type of object");
-      }
+        }
     return(objtype);
 }
 
@@ -1194,11 +1194,11 @@ unsigned CommonFG::childObjVersion(const H5std_string& objname) const
 //--------------------------------------------------------------------------
 H5G_obj_t CommonFG::getObjTypeByIdx(hsize_t idx) const
 {
-   H5G_obj_t obj_type = H5Gget_objtype_by_idx(getLocId(), idx);
-   if (obj_type == H5G_UNKNOWN)
-      throwException("getObjTypeByIdx", "H5Gget_objtype_by_idx failed");
+    H5G_obj_t obj_type = H5Gget_objtype_by_idx(getLocId(), idx);
+    if (obj_type == H5G_UNKNOWN)
+        throwException("getObjTypeByIdx", "H5Gget_objtype_by_idx failed");
 
-   return (obj_type);
+    return (obj_type);
 }
 
 //--------------------------------------------------------------------------
@@ -1245,7 +1245,7 @@ H5G_obj_t CommonFG::getObjTypeByIdx(hsize_t idx, H5std_string& type_name) const
         case H5G_RESERVED_6:
         case H5G_RESERVED_7:
         default:
-           throwException("getObjTypeByIdx", "H5Gget_objtype_by_idx failed");
+            throwException("getObjTypeByIdx", "H5Gget_objtype_by_idx failed");
     }
     return (obj_type);
 }
diff --git a/c++/src/H5CompType.cpp b/c++/src/H5CompType.cpp
index 2a60333..136493a 100644
--- a/c++/src/H5CompType.cpp
+++ b/c++/src/H5CompType.cpp
@@ -45,7 +45,7 @@ CompType::CompType() : DataType() {}
 ///\param       original - IN: Original CompType instance
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType::CompType( const CompType& original ) : DataType( original ) {}
+CompType::CompType(const CompType& original) : DataType(original) {}
 
 //--------------------------------------------------------------------------
 // Function:    CompType overloaded constructor
@@ -53,7 +53,7 @@ CompType::CompType( const CompType& original ) : DataType( original ) {}
 ///\param       existing_id - IN: Id of an existing compound datatype
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType::CompType( const hid_t existing_id ) : DataType( existing_id ) {}
+CompType::CompType(const hid_t existing_id) : DataType(existing_id) {}
 
 //--------------------------------------------------------------------------
 // Function:    CompType overloaded constructor
@@ -65,7 +65,7 @@ CompType::CompType( const hid_t existing_id ) : DataType( existing_id ) {}
 //              the compound datatype.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType::CompType( size_t size ) : DataType( H5T_COMPOUND, size ) {}
+CompType::CompType(size_t size) : DataType(H5T_COMPOUND, size) {}
 
 //--------------------------------------------------------------------------
 // Function:    CompType overloaded constructor
@@ -75,16 +75,16 @@ CompType::CompType( size_t size ) : DataType( H5T_COMPOUND, size ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType::CompType( const DataSet& dataset ) : DataType()
+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("CompType constructor", "H5Dget_type failed");
-   }
+    // 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("CompType constructor", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -96,13 +96,13 @@ CompType::CompType( const DataSet& dataset ) : DataType()
 //--------------------------------------------------------------------------
 int CompType::getNmembers() const
 {
-   int num_members = H5Tget_nmembers( id );
-   if( num_members < 0 )
-   {
-      throw DataTypeIException("CompType::getNmembers",
+    int num_members = H5Tget_nmembers(id);
+    if(num_members < 0)
+    {
+        throw DataTypeIException("CompType::getNmembers",
                 "H5Tget_nmembers returns negative number of members");
-   }
-   return( num_members );
+    }
+    return(num_members);
 }
 
 //--------------------------------------------------------------------------
@@ -113,17 +113,17 @@ int CompType::getNmembers() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string CompType::getMemberName( unsigned member_num ) const
+H5std_string CompType::getMemberName(unsigned member_num) const
 {
-    char* member_name_C = H5Tget_member_name( id, member_num );
-    if( member_name_C == NULL )  // NULL means failure
+    char* member_name_C = H5Tget_member_name(id, member_num);
+    if(member_name_C == NULL)  // NULL means failure
     {
         throw DataTypeIException("CompType::getMemberName",
                 "H5Tget_member_name returns NULL for member name");
     }
     H5std_string member_name = H5std_string(member_name_C); // convert C string to string
     H5free_memory(member_name_C); // free the C string
-    return( member_name ); // return the member name string
+    return(member_name); // return the member name string
 }
 
 //--------------------------------------------------------------------------
@@ -140,17 +140,17 @@ H5std_string CompType::getMemberName( unsigned member_num ) const
 //--------------------------------------------------------------------------
 int CompType::getMemberIndex(const char* name) const
 {
-   int member_index = H5Tget_member_index(id, name);
-   if( member_index < 0 )
-   {
-      throw DataTypeIException("CompType::getMemberIndex",
+    int member_index = H5Tget_member_index(id, name);
+    if(member_index < 0)
+    {
+        throw DataTypeIException("CompType::getMemberIndex",
                 "H5Tget_member_index returns negative value");
-   }
-   return( member_index );
+    }
+    return(member_index);
 }
 int CompType::getMemberIndex(const H5std_string& name) const
 {
-   return(getMemberIndex(name.c_str()));
+    return(getMemberIndex(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -169,10 +169,10 @@ int CompType::getMemberIndex(const H5std_string& name) const
 //              Note that byte offset being returned as 0 doesn't indicate
 //              a failure. (According to Quincey)
 //--------------------------------------------------------------------------
-size_t CompType::getMemberOffset( unsigned member_num ) const
+size_t CompType::getMemberOffset(unsigned member_num) const
 {
-   size_t offset = H5Tget_member_offset( id, member_num );
-   return( offset );
+    size_t offset = H5Tget_member_offset(id, member_num);
+    return(offset);
 }
 
 //--------------------------------------------------------------------------
@@ -185,15 +185,15 @@ size_t CompType::getMemberOffset( unsigned member_num ) const
 // Modification
 //              Modified to use H5Tget_member_class instead. - Jul, 2005
 //--------------------------------------------------------------------------
-H5T_class_t CompType::getMemberClass( unsigned member_num ) const
+H5T_class_t CompType::getMemberClass(unsigned member_num) const
 {
-   H5T_class_t member_class = H5Tget_member_class(id, member_num);
-   if( member_class == H5T_NO_CLASS )
-   {
-      throw DataTypeIException("CompType::getMemberClass",
+    H5T_class_t member_class = H5Tget_member_class(id, member_num);
+    if(member_class == H5T_NO_CLASS)
+    {
+        throw DataTypeIException("CompType::getMemberClass",
                 "H5Tget_member_class returns H5T_NO_CLASS");
-   }
-   return(member_class);
+    }
+    return(member_class);
 }
 
 // This private member function calls the C API to get the identifier
@@ -202,16 +202,16 @@ H5T_class_t CompType::getMemberClass( unsigned member_num ) const
 // the sub-types.
 hid_t CompType::p_get_member_type(unsigned member_num) const
 {
-   // get the id of the specified member first
-   hid_t member_type_id = H5Tget_member_type( id, member_num );
-   if( member_type_id > 0 )
-      return( member_type_id );
-   else
-   {
-      // p_get_member_type is private, caller will catch this exception
-      // then throw another with appropriate API name
-      throw DataTypeIException("", "H5Tget_member_type failed");
-   }
+    // get the id of the specified member first
+    hid_t member_type_id = H5Tget_member_type(id, member_num);
+    if(member_type_id > 0)
+        return(member_type_id);
+    else
+    {
+        // p_get_member_type is private, caller will catch this exception
+        // then throw another with appropriate API name
+        throw DataTypeIException("", "H5Tget_member_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -223,16 +223,16 @@ hid_t CompType::p_get_member_type(unsigned member_num) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataType CompType::getMemberDataType( unsigned member_num ) const
+DataType CompType::getMemberDataType(unsigned member_num) const
 {
-   try {
+    try {
         DataType datatype;
         f_DataType_setId(&datatype, p_get_member_type(member_num));
         return(datatype);
-   }
-   catch (DataTypeIException& E) {
+    }
+    catch (DataTypeIException& E) {
         throw DataTypeIException("CompType::getMemberDataType", E.getDetailMsg());
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -244,16 +244,16 @@ DataType CompType::getMemberDataType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-ArrayType CompType::getMemberArrayType( unsigned member_num ) const
+ArrayType CompType::getMemberArrayType(unsigned member_num) const
 {
-   try {
+    try {
         ArrayType arraytype(p_get_member_type(member_num));
         f_DataType_setId(&arraytype, p_get_member_type(member_num));
         return(arraytype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberArrayType", E.getDetailMsg());
-   }
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberArrayType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -265,16 +265,16 @@ ArrayType CompType::getMemberArrayType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-CompType CompType::getMemberCompType( unsigned member_num ) const
+CompType CompType::getMemberCompType(unsigned member_num) const
 {
-   try {
+    try {
       CompType comptype(p_get_member_type(member_num));
         f_DataType_setId(&comptype, p_get_member_type(member_num));
-      return(comptype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberCompType", E.getDetailMsg());
-   }
+        return(comptype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberCompType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -286,16 +286,16 @@ CompType CompType::getMemberCompType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType CompType::getMemberEnumType( unsigned member_num ) const
+EnumType CompType::getMemberEnumType(unsigned member_num) const
 {
-   try {
+    try {
       EnumType enumtype(p_get_member_type(member_num));
         f_DataType_setId(&enumtype, p_get_member_type(member_num));
-      return(enumtype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberEnumType", E.getDetailMsg());
-   }
+        return(enumtype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberEnumType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -307,16 +307,16 @@ EnumType CompType::getMemberEnumType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType CompType::getMemberIntType( unsigned member_num ) const
+IntType CompType::getMemberIntType(unsigned member_num) const
 {
-   try {
+    try {
       IntType inttype(p_get_member_type(member_num));
         f_DataType_setId(&inttype, p_get_member_type(member_num));
-      return(inttype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberIntType", E.getDetailMsg());
-   }
+        return(inttype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberIntType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -328,16 +328,16 @@ IntType CompType::getMemberIntType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType CompType::getMemberFloatType( unsigned member_num ) const
+FloatType CompType::getMemberFloatType(unsigned member_num) const
 {
-   try {
+    try {
       FloatType floatype(p_get_member_type(member_num));
         f_DataType_setId(&floatype, p_get_member_type(member_num));
-      return(floatype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberFloatType", E.getDetailMsg());
-   }
+        return(floatype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberFloatType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -349,16 +349,16 @@ FloatType CompType::getMemberFloatType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType CompType::getMemberStrType( unsigned member_num ) const
+StrType CompType::getMemberStrType(unsigned member_num) const
 {
-   try {
+    try {
       StrType strtype(p_get_member_type(member_num));
         f_DataType_setId(&strtype, p_get_member_type(member_num));
-      return(strtype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberStrType", E.getDetailMsg());
-   }
+        return(strtype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberStrType", E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -370,45 +370,45 @@ StrType CompType::getMemberStrType( unsigned member_num ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-VarLenType CompType::getMemberVarLenType( unsigned member_num ) const
+VarLenType CompType::getMemberVarLenType(unsigned member_num) const
 {
-   try {
+    try {
       VarLenType varlentype(p_get_member_type(member_num));
         f_DataType_setId(&varlentype, p_get_member_type(member_num));
-      return(varlentype);
-   }
-   catch (DataTypeIException& E) {
-      throw DataTypeIException("CompType::getMemberVarLenType", E.getDetailMsg());
-   }
+        return(varlentype);
+    }
+    catch (DataTypeIException& E) {
+        throw DataTypeIException("CompType::getMemberVarLenType", E.getDetailMsg());
+    }
 }
 
 /* old style of getMemberType - using overloads; new style above
-   returns the appropriate datatypes but has different named functions.
+    returns the appropriate datatypes but has different named functions.
    In the old style, a datatype must be passed into the function.
    May, 2004: These should be reconsidered to provide more convenience.
 // Returns the datatype of the specified member in this compound datatype.
 // Several overloading of getMemberType are for different datatypes
-void CompType::getMemberType( unsigned member_num, EnumType& enumtype ) const
+void CompType::getMemberType(unsigned member_num, EnumType& enumtype) const
 {
    p_get_member_type(member_num, enumtype);
 }
 
-void CompType::getMemberType( unsigned member_num, CompType& comptype ) const
+void CompType::getMemberType(unsigned member_num, CompType& comptype) const
 {
    p_get_member_type(member_num, comptype);
 }
 
-void CompType::getMemberType( unsigned member_num, IntType& inttype ) const
+void CompType::getMemberType(unsigned member_num, IntType& inttype) const
 {
    p_get_member_type(member_num, inttype);
 }
 
-void CompType::getMemberType( unsigned member_num, FloatType& floatype ) const
+void CompType::getMemberType(unsigned member_num, FloatType& floatype) const
 {
    p_get_member_type(member_num, floatype);
 }
 
-void CompType::getMemberType( unsigned member_num, StrType& strtype ) const
+void CompType::getMemberType(unsigned member_num, StrType& strtype) const
 {
    p_get_member_type(member_num, strtype);
 }
@@ -424,20 +424,20 @@ void CompType::getMemberType( unsigned member_num, StrType& strtype ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void CompType::insertMember( const H5std_string& name, size_t offset, const DataType& new_member ) const
+void CompType::insertMember(const H5std_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("CompType::insertMember", "H5Tinsert failed");
-   }
+    // 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("CompType::insertMember", "H5Tinsert failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -449,12 +449,12 @@ void CompType::insertMember( const H5std_string& name, size_t offset, const Data
 //--------------------------------------------------------------------------
 void CompType::pack() const
 {
-   // Calls C routine H5Tpack to remove padding
-   herr_t ret_value = H5Tpack( id );
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("CompType::pack", "H5Tpack failed");
-   }
+    // Calls C routine H5Tpack to remove padding
+    herr_t ret_value = H5Tpack(id);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("CompType::pack", "H5Tpack failed");
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5CompType.h b/c++/src/H5CompType.h
index bc7e114..e56dbf3 100644
--- a/c++/src/H5CompType.h
+++ b/c++/src/H5CompType.h
@@ -30,69 +30,69 @@ class H5_DLLCPP CompType : public DataType {
         CompType();
 
         // Creates a compound datatype using an existing id
-        CompType( const hid_t existing_id );
+        CompType(const hid_t existing_id);
 
         // Creates a new compound datatype, given the type's size
-        CompType( size_t size ); // H5Tcreate
+        CompType(size_t size); // H5Tcreate
 
         // Gets the compound datatype of the specified dataset
-        CompType( const DataSet& dataset );  // H5Dget_type
+        CompType(const DataSet& dataset);  // H5Dget_type
 
         // Copy constructor - makes a copy of original object
-        CompType( const CompType& original );
+        CompType(const CompType& original);
 
         // Returns the type class of the specified member of this compound
         // datatype.  It provides to the user a way of knowing what type
         // to create another datatype of the same class
-        H5T_class_t getMemberClass( unsigned member_num ) const;
+        H5T_class_t getMemberClass(unsigned member_num) const;
 
         // Returns the index of a member in this compound data type.
         int getMemberIndex(const char* name) const;
         int getMemberIndex(const H5std_string& name) const;
 
         // Returns the offset of a member of this compound datatype.
-        size_t getMemberOffset( unsigned memb_no ) const;
+        size_t getMemberOffset(unsigned memb_no) const;
 
         // Returns the name of a member of this compound datatype.
-        H5std_string getMemberName( unsigned member_num ) const;
+        H5std_string getMemberName(unsigned member_num) const;
 
         // Returns the generic datatype of the specified member in
         // this compound datatype.
-        DataType getMemberDataType( unsigned member_num ) const;
+        DataType getMemberDataType(unsigned member_num) const;
 
         // Returns the array datatype of the specified member in
         // this compound datatype.
-        ArrayType getMemberArrayType( unsigned member_num ) const;
+        ArrayType getMemberArrayType(unsigned member_num) const;
 
         // Returns the compound datatype of the specified member in
         // this compound datatype.
-        CompType getMemberCompType( unsigned member_num ) const;
+        CompType getMemberCompType(unsigned member_num) const;
 
         // Returns the enumeration datatype of the specified member in
         // this compound datatype.
-        EnumType getMemberEnumType( unsigned member_num ) const;
+        EnumType getMemberEnumType(unsigned member_num) const;
 
         // Returns the integer datatype of the specified member in
         // this compound datatype.
-        IntType getMemberIntType( unsigned member_num ) const;
+        IntType getMemberIntType(unsigned member_num) const;
 
         // Returns the floating-point datatype of the specified member in
         // this compound datatype.
-        FloatType getMemberFloatType( unsigned member_num ) const;
+        FloatType getMemberFloatType(unsigned member_num) const;
 
         // Returns the string datatype of the specified member in
         // this compound datatype.
-        StrType getMemberStrType( unsigned member_num ) const;
+        StrType getMemberStrType(unsigned member_num) const;
 
         // Returns the variable length datatype of the specified member in
         // this compound datatype.
-        VarLenType getMemberVarLenType( unsigned member_num ) const;
+        VarLenType getMemberVarLenType(unsigned member_num) const;
 
         // Returns the number of members in this compound datatype.
         int getNmembers() const;
 
         // Adds a new member to this compound datatype.
-        void insertMember( const H5std_string& name, size_t offset, const DataType& new_member ) const;
+        void insertMember(const H5std_string& name, size_t offset, const DataType& new_member) const;
 
         // Recursively removes padding from within this compound datatype.
         void pack() const;
diff --git a/c++/src/H5DataSet.cpp b/c++/src/H5DataSet.cpp
index cc2e6b4..aba2fa3 100644
--- a/c++/src/H5DataSet.cpp
+++ b/c++/src/H5DataSet.cpp
@@ -130,18 +130,18 @@ DataSet::DataSet(const Attribute& attr, const void* ref, H5R_type_t ref_type) :
 //--------------------------------------------------------------------------
 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("DataSet::getSpace", "H5Dget_space failed");
-   }
-   //create dataspace object using the existing id then return the object
-   DataSpace data_space;
-   f_DataSpace_setId(&data_space, dataspace_id);
-   return( data_space );
+    // 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("DataSet::getSpace", "H5Dget_space failed");
+    }
+    //create dataspace object using the existing id then return the object
+    DataSpace data_space;
+    f_DataSpace_setId(&data_space, dataspace_id);
+    return(data_space);
 }
 
 // This private member function calls the C API to get the identifier
@@ -149,13 +149,13 @@ DataSpace DataSet::getSpace() const
 // by the various AbstractDs functions to get the specific datatype.
 hid_t DataSet::p_get_type() const
 {
-   hid_t type_id = H5Dget_type( id );
-   if( type_id > 0 )
-      return( type_id );
-   else
-   {
-      throw DataSetIException("", "H5Dget_type failed");
-   }
+    hid_t type_id = H5Dget_type(id);
+    if(type_id > 0)
+        return(type_id);
+    else
+    {
+        throw DataSetIException("", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -167,16 +167,16 @@ hid_t DataSet::p_get_type() const
 //--------------------------------------------------------------------------
 DSetCreatPropList DataSet::getCreatePlist() const
 {
-   hid_t create_plist_id = H5Dget_create_plist( id );
-   if( create_plist_id < 0 )
-   {
-      throw DataSetIException("DataSet::getCreatePlist", "H5Dget_create_plist failed");
-   }
-
-   // create and return the DSetCreatPropList object
-   DSetCreatPropList create_plist;
-   f_PropList_setId(&create_plist, create_plist_id);
-   return(create_plist);
+    hid_t create_plist_id = H5Dget_create_plist(id);
+    if(create_plist_id < 0)
+    {
+        throw DataSetIException("DataSet::getCreatePlist", "H5Dget_create_plist failed");
+    }
+
+    // create and return the DSetCreatPropList object
+    DSetCreatPropList create_plist;
+    f_PropList_setId(&create_plist, create_plist_id);
+    return(create_plist);
 }
 
 //--------------------------------------------------------------------------
@@ -190,8 +190,8 @@ DSetCreatPropList DataSet::getCreatePlist() const
 //--------------------------------------------------------------------------
 hsize_t DataSet::getStorageSize() const
 {
-   hsize_t storage_size = H5Dget_storage_size(id);
-   return(storage_size);
+    hsize_t storage_size = H5Dget_storage_size(id);
+    return(storage_size);
 }
 
 //--------------------------------------------------------------------------
@@ -207,7 +207,7 @@ size_t DataSet::getInMemDataSize() const
 
     // Get the data type of this dataset
     hid_t mem_type_id = H5Dget_type(id);
-    if( mem_type_id < 0 )
+    if(mem_type_id < 0)
     {
         throw DataSetIException(func, "H5Dget_type failed");
     }
@@ -268,14 +268,14 @@ size_t DataSet::getInMemDataSize() const
 //--------------------------------------------------------------------------
 haddr_t DataSet::getOffset() const
 {
-   haddr_t ds_addr; // for address of dataset
-
-   ds_addr = H5Dget_offset(id);
-   if( ds_addr == HADDR_UNDEF )
-   {
-      throw DataSetIException("DataSet::getOffset", "H5Dget_offset returned HADDR_UNDEF");
-   }
-   return(ds_addr);
+    haddr_t ds_addr; // for address of dataset
+
+    ds_addr = H5Dget_offset(id);
+    if(ds_addr == HADDR_UNDEF)
+    {
+        throw DataSetIException("DataSet::getOffset", "H5Dget_offset returned HADDR_UNDEF");
+    }
+    return(ds_addr);
 }
 
 //--------------------------------------------------------------------------
@@ -287,11 +287,11 @@ haddr_t DataSet::getOffset() const
 //--------------------------------------------------------------------------
 void DataSet::getSpaceStatus(H5D_space_status_t& status) const
 {
-   herr_t ret_value = H5Dget_space_status(id, &status);
-   if( ret_value < 0 )
-   {
-      throw DataSetIException("DataSet::getSpaceStatus", "H5Dget_space_status failed");
-   }
+    herr_t ret_value = H5Dget_space_status(id, &status);
+    if(ret_value < 0)
+    {
+        throw DataSetIException("DataSet::getSpaceStatus", "H5Dget_space_status failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -305,20 +305,20 @@ void DataSet::getSpaceStatus(H5D_space_status_t& status) const
 // Modification
 //              Replaced the version without const parameter - Apr, 2014
 //--------------------------------------------------------------------------
-hsize_t DataSet::getVlenBufSize(const DataType& type, const DataSpace& space ) const
+hsize_t DataSet::getVlenBufSize(const DataType& type, const DataSpace& space) const
 {
-   // Obtain identifiers for C API
-   hid_t type_id = type.getId();
-   hid_t space_id = space.getId();
-
-   hsize_t size; // for amount of storage
-
-   herr_t ret_value = H5Dvlen_get_buf_size( id, type_id, space_id, &size );
-   if( ret_value < 0 )
-   {
-      throw DataSetIException("DataSet::getVlenBufSize", "H5Dvlen_get_buf_size failed");
-   }
-   return( size );
+    // Obtain identifiers for C API
+    hid_t type_id = type.getId();
+    hid_t space_id = space.getId();
+
+    hsize_t size; // for amount of storage
+
+    herr_t ret_value = H5Dvlen_get_buf_size(id, type_id, space_id, &size);
+    if(ret_value < 0)
+    {
+        throw DataSetIException("DataSet::getVlenBufSize", "H5Dvlen_get_buf_size failed");
+    }
+    return(size);
 }
 
 //--------------------------------------------------------------------------
@@ -334,9 +334,9 @@ hsize_t DataSet::getVlenBufSize(const DataType& type, const DataSpace& space ) c
 //              Removed from documentation. -BMR, 2016/03/07 1.8.17 and 1.10.0
 //              Removed from code. -BMR, 2016/08/11 1.8.18 and 1.10.1
 //--------------------------------------------------------------------------
-//hsize_t DataSet::getVlenBufSize( DataType& type, DataSpace& space ) const
+//hsize_t DataSet::getVlenBufSize(DataType& type, DataSpace& space) const
 //{
-//    return(getVlenBufSize(type, space));
+//  return(getVlenBufSize(type, space));
 //}
 
 //--------------------------------------------------------------------------
@@ -350,18 +350,18 @@ hsize_t DataSet::getVlenBufSize(const DataType& type, const DataSpace& space ) c
 ///\exception   H5::DataSetIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSet::vlenReclaim(const DataType& type, const DataSpace& space, const DSetMemXferPropList& xfer_plist, void* buf )
+void DataSet::vlenReclaim(const DataType& type, const DataSpace& space, const DSetMemXferPropList& xfer_plist, void* buf)
 {
-   // 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();
-
-   herr_t ret_value = H5Dvlen_reclaim( type_id, space_id, xfer_plist_id, buf );
-   if( ret_value < 0 )
-   {
-      throw DataSetIException("DataSet::vlenReclaim", "H5Dvlen_reclaim failed");
-   }
+    // 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();
+
+    herr_t ret_value = H5Dvlen_reclaim(type_id, space_id, xfer_plist_id, buf);
+    if(ret_value < 0)
+    {
+        throw DataSetIException("DataSet::vlenReclaim", "H5Dvlen_reclaim failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -380,16 +380,16 @@ void DataSet::vlenReclaim(const DataType& type, const DataSpace& space, const DS
 //--------------------------------------------------------------------------
 void DataSet::vlenReclaim(void* buf, const DataType& type, const DataSpace& space, const DSetMemXferPropList& xfer_plist)
 {
-   // 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();
-
-   herr_t ret_value = H5Dvlen_reclaim(type_id, space_id, xfer_plist_id, buf);
-   if (ret_value < 0)
-   {
-      throw DataSetIException("DataSet::vlenReclaim", "H5Dvlen_reclaim failed");
-   }
+    // 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();
+
+    herr_t ret_value = H5Dvlen_reclaim(type_id, space_id, xfer_plist_id, buf);
+    if (ret_value < 0)
+    {
+        throw DataSetIException("DataSet::vlenReclaim", "H5Dvlen_reclaim failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -407,19 +407,19 @@ void DataSet::vlenReclaim(void* buf, const DataType& type, const DataSpace& spac
 ///             to memory datatype \a mem_type and dataspace \a mem_space.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSet::read( void* buf, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
+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("DataSet::read", "H5Dread failed");
-   }
+    // 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("DataSet::read", "H5Dread failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -483,19 +483,19 @@ void DataSet::read(H5std_string& strg, const DataType& mem_type, const DataSpace
 ///             and dataspace.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSet::write( const void* buf, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
+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("DataSet::write", "H5Dwrite failed");
-   }
+    // 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("DataSet::write", "H5Dwrite failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -508,7 +508,7 @@ void DataSet::write( const void* buf, const DataType& mem_type, const DataSpace&
 //              Modified to pass the buffer into H5Dwrite properly depending
 //              whether the dataset has variable- or fixed-length string.
 //--------------------------------------------------------------------------
-void DataSet::write( const H5std_string& strg, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist ) const
+void DataSet::write(const H5std_string& strg, const DataType& mem_type, const DataSpace& mem_space, const DataSpace& file_space, const DSetMemXferPropList& xfer_plist) const
 {
     // Check if this attribute has variable-len string or fixed-len string and
     // proceed appropriately.
@@ -518,11 +518,11 @@ void DataSet::write( const H5std_string& strg, const DataType& mem_type, const D
         throw DataSetIException("DataSet::write", "H5Tis_variable_str failed");
     }
 
-   // 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();
+    // 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();
 
     // Convert string to C-string
     const char* strg_C;
@@ -532,12 +532,12 @@ void DataSet::write( const H5std_string& strg, const DataType& mem_type, const D
     // Pass string in differently depends on variable or fixed length
     if (!is_variable_len)
     {
-        ret_value = H5Dwrite( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, strg_C );
+        ret_value = H5Dwrite(id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, strg_C);
     }
     else
     {
         // passing string argument by address
-        ret_value = H5Dwrite( id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, &strg_C );
+        ret_value = H5Dwrite(id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, &strg_C);
     }
     if (ret_value < 0)
     {
@@ -562,18 +562,18 @@ void DataSet::write( const H5std_string& strg, const DataType& mem_type, const D
 ///             under development.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int DataSet::iterateElems( void* buf, const DataType& type, const DataSpace& space, H5D_operator_t op, void* op_data )
+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("DataSet::iterateElems", "H5Diterate failed");
-   }
+    // 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("DataSet::iterateElems", "H5Diterate failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -588,11 +588,11 @@ int DataSet::iterateElems( void* buf, const DataType& type, const DataSpace& spa
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5D.html#Dataset-Extend
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSet::extend( const hsize_t* size ) const
+void DataSet::extend(const hsize_t* size) const
 {
-   herr_t ret_value = H5Dset_extent( id, size );
-   if( ret_value < 0 )  // raise exception when H5Dset_extent returns a neg value
-      throw DataSetIException("DataSet::extend", "H5Dset_extent failed");
+    herr_t ret_value = H5Dset_extent(id, size);
+    if(ret_value < 0)  // raise exception when H5Dset_extent returns a neg value
+        throw DataSetIException("DataSet::extend", "H5Dset_extent failed");
 }
 
 //--------------------------------------------------------------------------
@@ -613,7 +613,7 @@ void DataSet::fillMemBuf(const void *fill, const DataType& fill_type, void *buf,
     hid_t buf_type_id = buf_type.getId();
     hid_t space_id = space.getId();
     herr_t ret_value = H5Dfill(fill, fill_type_id, buf, buf_type_id, space_id);
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw DataSetIException("DataSet::fillMemBuf", "H5Dfill failed");
     }
@@ -657,7 +657,7 @@ void DataSet::fillMemBuf(void *buf, const DataType& buf_type, const DataSpace& s
     hid_t buf_type_id = buf_type.getId();
     hid_t space_id = space.getId();
     herr_t ret_value = H5Dfill(NULL, buf_type_id, buf, buf_type_id, space_id);
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw DataSetIException("DataSet::fillMemBuf", "H5Dfill failed");
     }
@@ -696,7 +696,7 @@ void DataSet::fillMemBuf(void *buf, const DataType& buf_type, const DataSpace& s
 //--------------------------------------------------------------------------
 hid_t DataSet::getId() const
 {
-   return(id);
+    return(id);
 }
 
 //--------------------------------------------------------------------------
@@ -725,7 +725,7 @@ void DataSet::p_read_fixed_len(const hid_t mem_type_id, const hid_t mem_space_id
 
         herr_t ret_value = H5Dread(id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, strg_C);
 
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             delete []strg_C;    // de-allocate for fixed-len string
             throw DataSetIException("DataSet::read", "H5Dread failed for fixed length string");
@@ -756,7 +756,7 @@ void DataSet::p_read_variable_len(const hid_t mem_type_id, const hid_t mem_space
     // Read dataset, no allocation for variable-len string; C library will
     herr_t ret_value = H5Dread(id, mem_type_id, mem_space_id, file_space_id, xfer_plist_id, &strg_C);
 
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw DataSetIException("DataSet::read", "H5Dread failed for variable length string");
     }
@@ -788,8 +788,8 @@ void DataSet::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw DataSetIException(inMemFunc("p_setId"), close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 
 //--------------------------------------------------------------------------
@@ -820,8 +820,8 @@ void DataSet::close()
 {
     if (p_valid_id(id))
     {
-        herr_t ret_value = H5Dclose( id );
-        if( ret_value < 0 )
+        herr_t ret_value = H5Dclose(id);
+        if(ret_value < 0)
         {
             throw DataSetIException("DataSet::close", "H5Dclose failed");
         }
diff --git a/c++/src/H5DataSet.h b/c++/src/H5DataSet.h
index 049ca48..b646a7a 100644
--- a/c++/src/H5DataSet.h
+++ b/c++/src/H5DataSet.h
@@ -34,7 +34,7 @@ class H5_DLLCPP DataSet : public H5Object, public AbstractDs {
         virtual void close();
 
         // Extends the dataset with unlimited dimension.
-        void extend( const hsize_t* size ) const;
+        void extend(const hsize_t* size) const;
 
         // Fills a selection in memory with a value
         void fillMemBuf(const void *fill, const DataType& fill_type, void *buf, const DataType& buf_type, const DataSpace& space) const;
@@ -63,27 +63,27 @@ class H5_DLLCPP DataSet : public H5Object, public AbstractDs {
         virtual size_t getInMemDataSize() const;
 
         // Returns the number of bytes required to store VL data.
-        hsize_t getVlenBufSize(const DataType& type, const DataSpace& space ) const;
+        hsize_t getVlenBufSize(const DataType& type, const DataSpace& space) const;
         //hsize_t getVlenBufSize(DataType& type, DataSpace& space) const; // removed from 1.8.18 and 1.10.1
 
         // Reclaims VL datatype memory buffers.
-        static void vlenReclaim(const DataType& type, const DataSpace& space, const DSetMemXferPropList& xfer_plist, void* buf );
+        static void vlenReclaim(const DataType& type, const DataSpace& space, const DSetMemXferPropList& xfer_plist, void* buf);
         static void vlenReclaim(void *buf, const DataType& type, const DataSpace& space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT);
 
         // 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;
-        void read( H5std_string& buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+        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;
+        void read(H5std_string& 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;
-        void write( const H5std_string& buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
+        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;
+        void write(const H5std_string& 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 );
+        int iterateElems(void* buf, const DataType& type, const DataSpace& space, H5D_operator_t op, void* op_data = NULL);
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("DataSet"); }
@@ -96,7 +96,7 @@ class H5_DLLCPP DataSet : public H5Object, public AbstractDs {
         DataSet();
 
         // Copy constructor.
-        DataSet( const DataSet& original );
+        DataSet(const DataSet& original);
 
         // Creates a copy of an existing DataSet using its id.
         DataSet(const hid_t existing_id);
diff --git a/c++/src/H5DataSpace.cpp b/c++/src/H5DataSpace.cpp
index 4869a0c..538c245 100644
--- a/c++/src/H5DataSpace.cpp
+++ b/c++/src/H5DataSpace.cpp
@@ -97,11 +97,11 @@ const DataSpace& DataSpace::ALL = *getConstant();
 //--------------------------------------------------------------------------
 DataSpace::DataSpace(H5S_class_t type) : IdComponent()
 {
-   id = H5Screate( type );
-   if( id < 0 )
-   {
-      throw DataSpaceIException("DataSpace constructor", "H5Screate failed");
-   }
+    id = H5Screate(type);
+    if(id < 0)
+    {
+        throw DataSpaceIException("DataSpace constructor", "H5Screate failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -113,13 +113,13 @@ DataSpace::DataSpace(H5S_class_t type) : IdComponent()
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSpace::DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims) : IdComponent()
+DataSpace::DataSpace(int rank, const hsize_t * dims, const hsize_t * maxdims) : IdComponent()
 {
-   id = H5Screate_simple( rank, dims, maxdims );
-   if( id < 0 )
-   {
-      throw DataSpaceIException("DataSpace constructor", "H5Screate_simple failed");
-   }
+    id = H5Screate_simple(rank, dims, maxdims);
+    if(id < 0)
+    {
+        throw DataSpaceIException("DataSpace constructor", "H5Screate_simple failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -158,23 +158,23 @@ DataSpace::DataSpace(const DataSpace& original) : IdComponent(), id(original.id)
 //              - Replaced decRefCount with close() to let the C library
 //              handle the reference counting - BMR, Jun 1, 2006
 //--------------------------------------------------------------------------
-void DataSpace::copy( const DataSpace& like_space )
+void DataSpace::copy(const DataSpace& like_space)
 {
-   // If this object has an hdf5 valid id, close it
-   if( id != H5S_ALL ) {
-      try {
+    // If this object has an hdf5 valid id, close it
+    if(id != H5S_ALL) {
+        try {
          close();
-      }
-      catch (Exception& close_error) {
-         throw DataSpaceIException("DataSpace::copy", close_error.getDetailMsg());
-      }
-   }  // end if
+        }
+        catch (Exception& close_error) {
+        throw DataSpaceIException("DataSpace::copy", close_error.getDetailMsg());
+        }
+    }  // end if
 
-   // call C routine to copy the dataspace
-   id = H5Scopy( like_space.getId() );
+    // call C routine to copy the dataspace
+    id = H5Scopy(like_space.getId());
 
-   if( id < 0 )
-      throw DataSpaceIException("DataSpace::copy", "H5Scopy failed");
+    if(id < 0)
+        throw DataSpaceIException("DataSpace::copy", "H5Scopy failed");
 }
 
 //--------------------------------------------------------------------------
@@ -188,7 +188,7 @@ void DataSpace::copy( const DataSpace& like_space )
 //              the new id in the left hand side object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSpace& DataSpace::operator=( const DataSpace& rhs )
+DataSpace& DataSpace::operator=(const DataSpace& rhs)
 {
     if (this != &rhs)
         copy(rhs);
@@ -205,16 +205,16 @@ DataSpace& DataSpace::operator=( const DataSpace& rhs )
 //--------------------------------------------------------------------------
 bool DataSpace::isSimple () const
 {
-   htri_t simple = H5Sis_simple( id );
-   if( simple > 0 )
-      return true;
-   else if( simple == 0 )
-      return false;
-   else
-   {
-      throw DataSpaceIException("DataSpace::isSimple",
+    htri_t simple = H5Sis_simple(id);
+    if(simple > 0)
+        return true;
+    else if(simple == 0)
+        return false;
+    else
+    {
+        throw DataSpaceIException("DataSpace::isSimple",
                 "H5Sis_simple returns negative value");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -229,13 +229,13 @@ bool DataSpace::isSimple () const
 ///             it to be re-defined.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::offsetSimple ( const hssize_t* offset ) const
+void DataSpace::offsetSimple (const hssize_t* offset) const
 {
-   herr_t ret_value = H5Soffset_simple( id, offset );
-   if( ret_value < 0 )
-   {
-      throw DataSpaceIException("DataSpace::offsetSimple", "H5Soffset_simple failed");
-   }
+    herr_t ret_value = H5Soffset_simple(id, offset);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::offsetSimple", "H5Soffset_simple failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -248,15 +248,15 @@ void DataSpace::offsetSimple ( const hssize_t* offset ) const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int DataSpace::getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims ) const
+int DataSpace::getSimpleExtentDims (hsize_t *dims, hsize_t *maxdims) const
 {
-   int ndims = H5Sget_simple_extent_dims( id, dims, maxdims );
-   if( ndims < 0 )
-   {
-      throw DataSpaceIException("DataSpace::getSimpleExtentDims",
+    int ndims = H5Sget_simple_extent_dims(id, dims, maxdims);
+    if(ndims < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSimpleExtentDims",
                 "H5Sget_simple_extent_dims returns negative number of dimensions");
-   }
-   return( ndims );
+    }
+    return(ndims);
 }
 
 //--------------------------------------------------------------------------
@@ -268,13 +268,13 @@ int DataSpace::getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims ) const
 //--------------------------------------------------------------------------
 int DataSpace::getSimpleExtentNdims () const
 {
-   int ndims = H5Sget_simple_extent_ndims( id );
-   if( ndims < 0 )
-   {
-      throw DataSpaceIException("DataSpace::getSimpleExtentNdims",
+    int ndims = H5Sget_simple_extent_ndims(id);
+    if(ndims < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSimpleExtentNdims",
                 "H5Sget_simple_extent_ndims returns negative value for dimensionality of the dataspace");
-   }
-   return( ndims );
+    }
+    return(ndims);
 }
 
 //--------------------------------------------------------------------------
@@ -290,15 +290,15 @@ int DataSpace::getSimpleExtentNdims () const
 //--------------------------------------------------------------------------
 hssize_t DataSpace::getSimpleExtentNpoints () const
 {
-   hssize_t num_elements = H5Sget_simple_extent_npoints( id );
+    hssize_t num_elements = H5Sget_simple_extent_npoints(id);
 
-   if( num_elements > -1 )
-      return( num_elements );
-   else
-   {
-      throw DataSpaceIException("DataSpace::getSimpleExtentNpoints",
+    if(num_elements > -1)
+        return(num_elements);
+    else
+    {
+        throw DataSpaceIException("DataSpace::getSimpleExtentNpoints",
         "H5Sget_simple_extent_npoints returns negative value for the number of elements in the dataspace");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -310,13 +310,13 @@ hssize_t DataSpace::getSimpleExtentNpoints () const
 //--------------------------------------------------------------------------
 H5S_class_t DataSpace::getSimpleExtentType () const
 {
-   H5S_class_t class_name = H5Sget_simple_extent_type( id );
-   if( class_name == H5S_NO_CLASS )
-   {
-      throw DataSpaceIException("DataSpace::getSimpleExtentType",
+    H5S_class_t class_name = H5Sget_simple_extent_type(id);
+    if(class_name == H5S_NO_CLASS)
+    {
+        throw DataSpaceIException("DataSpace::getSimpleExtentType",
                 "H5Sget_simple_extent_type returns H5S_NO_CLASS");
-   }
-   return( class_name );
+    }
+    return(class_name);
 }
 
 //--------------------------------------------------------------------------
@@ -330,12 +330,12 @@ H5S_class_t DataSpace::getSimpleExtentType () const
 //--------------------------------------------------------------------------
 void DataSpace::extentCopy (const 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("DataSpace::extentCopy", "H5Sextent_copy failed");
-   }
+    hid_t dest_space_id = dest_space.getId();
+    herr_t ret_value = H5Sextent_copy(dest_space_id, id);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::extentCopy", "H5Sextent_copy failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -351,7 +351,7 @@ void DataSpace::extentCopy (const DataSpace& dest_space) const
 //              Removed from documentation. -BMR, 2016/03/07 1.8.17 and 1.10.0
 //              Removed from code. -BMR, 2016/08/11 1.8.18 and 1.10.1
 //--------------------------------------------------------------------------
-//void DataSpace::extentCopy( DataSpace& dest_space ) const
+//void DataSpace::extentCopy(DataSpace& dest_space) const
 //{
 //    extentCopy(dest_space);
 //}
@@ -365,14 +365,14 @@ void DataSpace::extentCopy (const DataSpace& dest_space) const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size ) const
+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("DataSpace::setExtentSimple", "H5Sset_extent_simple failed");
-   }
+    herr_t ret_value;
+    ret_value = H5Sset_extent_simple(id, rank, current_size, maximum_size);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::setExtentSimple", "H5Sset_extent_simple failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -384,11 +384,11 @@ void DataSpace::setExtentSimple( int rank, const hsize_t *current_size, const hs
 //--------------------------------------------------------------------------
 void DataSpace::setExtentNone () const
 {
-   herr_t ret_value = H5Sset_extent_none( id );
-   if( ret_value < 0 )
-   {
-      throw DataSpaceIException("DataSpace::setExtentNone", "H5Sset_extent_none failed");
-   }
+    herr_t ret_value = H5Sset_extent_none(id);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::setExtentNone", "H5Sset_extent_none failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -400,13 +400,13 @@ void DataSpace::setExtentNone () const
 //--------------------------------------------------------------------------
 hssize_t DataSpace::getSelectNpoints () const
 {
-   hssize_t num_elements = H5Sget_select_npoints( id );
-   if( num_elements < 0 )
-   {
-      throw DataSpaceIException("DataSpace::getSelectNpoints",
+    hssize_t num_elements = H5Sget_select_npoints(id);
+    if(num_elements < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectNpoints",
                 "H5Sget_select_npoints returns negative value for number of elements in the dataspace selection");
-   }
-   return( num_elements );
+    }
+    return(num_elements);
 }
 
 //--------------------------------------------------------------------------
@@ -418,13 +418,13 @@ hssize_t DataSpace::getSelectNpoints () const
 //--------------------------------------------------------------------------
 hssize_t DataSpace::getSelectHyperNblocks () const
 {
-   hssize_t num_blocks = H5Sget_select_hyper_nblocks( id );
-   if( num_blocks < 0 )
-   {
-      throw DataSpaceIException("DataSpace::getSelectHyperNblocks",
+    hssize_t num_blocks = H5Sget_select_hyper_nblocks(id);
+    if(num_blocks < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectHyperNblocks",
                 "H5Sget_select_hyper_nblocks returns negative value for the number of hyperslab blocks");
-   }
-   return( num_blocks );
+    }
+    return(num_blocks);
 }
 
 //--------------------------------------------------------------------------
@@ -436,15 +436,15 @@ hssize_t DataSpace::getSelectHyperNblocks () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const
+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("DataSpace::getSelectHyperBlocklist",
+    herr_t ret_value;
+    ret_value = H5Sget_select_hyper_blocklist(id, startblock, numblocks, buf);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectHyperBlocklist",
                 "H5Sget_select_hyper_blocklist failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -456,13 +456,13 @@ void DataSpace::getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks,
 //--------------------------------------------------------------------------
 hssize_t DataSpace::getSelectElemNpoints () const
 {
-   hssize_t num_points = H5Sget_select_elem_npoints( id );
-   if( num_points < 0 )
-   {
-      throw DataSpaceIException("DataSpace::getSelectElemNpoints",
+    hssize_t num_points = H5Sget_select_elem_npoints(id);
+    if(num_points < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectElemNpoints",
                 "H5Sget_select_elem_npoints failed");
-   }
-   return( num_points );
+    }
+    return(num_points);
 }
 
 //--------------------------------------------------------------------------
@@ -478,15 +478,15 @@ hssize_t DataSpace::getSelectElemNpoints () const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5S.html#Dataspace-SelectElemPointList
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const
+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("DataSpace::getSelectElemPointlist",
+    herr_t ret_value;
+    ret_value = H5Sget_select_elem_pointlist(id, startpoint, numpoints, buf);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectElemPointlist",
                 "H5Sget_select_elem_pointlist failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -502,14 +502,14 @@ void DataSpace::getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints,
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5S.html#Dataspace-SelectBounds
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::getSelectBounds ( hsize_t* start, hsize_t* end ) const
+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("DataSpace::getSelectBounds",
+    herr_t ret_value = H5Sget_select_bounds(id, start, end);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::getSelectBounds",
                 "H5Sget_select_bounds failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -528,15 +528,15 @@ void DataSpace::getSelectBounds ( hsize_t* start, hsize_t* end ) const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5S.html#Dataspace-SelectElements
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::selectElements ( H5S_seloper_t op, const size_t num_elements, const hsize_t *coord) const
+void DataSpace::selectElements (H5S_seloper_t op, const size_t num_elements, const hsize_t *coord) const
 {
-   herr_t ret_value;
-   ret_value = H5Sselect_elements( id, op, num_elements, coord );
-   if( ret_value < 0 )
-   {
-      throw DataSpaceIException("DataSpace::selectElements",
+    herr_t ret_value;
+    ret_value = H5Sselect_elements(id, op, num_elements, coord);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::selectElements",
                 "H5Sselect_elements failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -548,11 +548,11 @@ void DataSpace::selectElements ( H5S_seloper_t op, const size_t num_elements, co
 //--------------------------------------------------------------------------
 void DataSpace::selectAll () const
 {
-   herr_t ret_value = H5Sselect_all( id );
-   if( ret_value < 0 )
-   {
-      throw DataSpaceIException("DataSpace::selectAll", "H5Sselect_all failed");
-   }
+    herr_t ret_value = H5Sselect_all(id);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::selectAll", "H5Sselect_all failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -564,12 +564,12 @@ void DataSpace::selectAll () const
 //--------------------------------------------------------------------------
 void DataSpace::selectNone () const
 {
-  herr_t ret_value = H5Sselect_none( id );
-   if( ret_value < 0 )
-   {
-      throw DataSpaceIException("DataSpace::selectNone",
+    herr_t ret_value = H5Sselect_none(id);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::selectNone",
                 "H5Sselect_none failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -583,16 +583,16 @@ void DataSpace::selectNone () const
 //--------------------------------------------------------------------------
 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("DataSpace::selectValid",
+    htri_t ret_value = H5Sselect_valid(id);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else
+    {
+        throw DataSpaceIException("DataSpace::selectValid",
                 "H5Sselect_valid returns negative value");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -610,15 +610,15 @@ bool DataSpace::selectValid () const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5S.html#Dataspace-SelectHyperslab
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hsize_t *start, const hsize_t *stride, const hsize_t *block ) const
+void DataSpace::selectHyperslab(H5S_seloper_t op, const hsize_t *count, const hsize_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("DataSpace::selectHyperslab",
+    herr_t ret_value;
+    ret_value = H5Sselect_hyperslab(id, op, start, stride, count, block);
+    if(ret_value < 0)
+    {
+        throw DataSpaceIException("DataSpace::selectHyperslab",
                 "H5Sselect_hyperslab failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -635,7 +635,7 @@ void DataSpace::selectHyperslab( H5S_seloper_t op, const hsize_t *count, const h
 //--------------------------------------------------------------------------
 hid_t DataSpace::getId() const
 {
-   return(id);
+    return(id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -660,8 +660,8 @@ void DataSpace::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw DataSpaceIException(inMemFunc("p_setId"), close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -678,7 +678,7 @@ void DataSpace::close()
     if (p_valid_id(id))
     {
         herr_t ret_value = H5Sclose(id);
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             throw DataSpaceIException("DataSpace::close", "H5Sclose failed");
         }
diff --git a/c++/src/H5DataSpace.h b/c++/src/H5DataSpace.h
index fc9c54e..2168f4d 100644
--- a/c++/src/H5DataSpace.h
+++ b/c++/src/H5DataSpace.h
@@ -42,7 +42,7 @@ class H5_DLLCPP DataSpace : public IdComponent {
         DataSpace(const DataSpace& original);
 
         // Assignment operator
-        DataSpace& operator=( const DataSpace& rhs );
+        DataSpace& operator=(const DataSpace& rhs);
 
         // Closes this dataspace.
         virtual void close();
@@ -56,16 +56,16 @@ class H5_DLLCPP DataSpace : public IdComponent {
         //void extentCopy(DataSpace& dest_space) const;
 
         // Gets the bounding box containing the current selection.
-        void getSelectBounds( hsize_t* start, hsize_t* end ) const;
+        void getSelectBounds(hsize_t* start, hsize_t* end) 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;
+        void getSelectElemPointlist(hsize_t startpoint, hsize_t numpoints, hsize_t *buf) const;
 
         // Gets the list of hyperslab blocks currently selected.
-        void getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const;
+        void getSelectHyperBlocklist(hsize_t startblock, hsize_t numblocks, hsize_t *buf) const;
 
         // Get number of hyperslab blocks.
         hssize_t getSelectHyperNblocks() const;
@@ -74,7 +74,7 @@ class H5_DLLCPP DataSpace : public IdComponent {
         hssize_t getSelectNpoints() const;
 
         // Retrieves dataspace dimension size and maximum size.
-        int getSimpleExtentDims( hsize_t *dims, hsize_t *maxdims = NULL ) const;
+        int getSimpleExtentDims(hsize_t *dims, hsize_t *maxdims = NULL) const;
 
         // Gets the dimensionality of this dataspace.
         int getSimpleExtentNdims() const;
@@ -90,17 +90,17 @@ class H5_DLLCPP DataSpace : public IdComponent {
         bool isSimple() const;
 
         // Sets the offset of this simple dataspace.
-        void offsetSimple( const hssize_t* offset ) const;
+        void offsetSimple(const hssize_t* offset) const;
 
         // Selects the entire dataspace.
         void selectAll() 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 hsize_t *coord) const;
+        void selectElements(H5S_seloper_t op, const size_t num_elements, const hsize_t *coord) const;
 
         // Selects a hyperslab region to add to the current selected region.
-        void selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hsize_t *start, const hsize_t *stride = NULL, const hsize_t *block = NULL ) const;
+        void selectHyperslab(H5S_seloper_t op, const hsize_t *count, const hsize_t *start, const hsize_t *stride = NULL, const hsize_t *block = NULL) const;
 
         // Resets the selection region to include no elements.
         void selectNone() const;
@@ -112,7 +112,7 @@ class H5_DLLCPP DataSpace : public IdComponent {
         void setExtentNone() 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;
+        void setExtentSimple(int rank, const hsize_t *current_size, const hsize_t *maximum_size = NULL) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("DataSpace"); }
diff --git a/c++/src/H5DataType.cpp b/c++/src/H5DataType.cpp
index c9a0c6b..f29978b 100644
--- a/c++/src/H5DataType.cpp
+++ b/c++/src/H5DataType.cpp
@@ -80,14 +80,14 @@ DataType::DataType(const hid_t existing_id) : H5Object(), id(existing_id)
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataType::DataType( const H5T_class_t type_class, size_t size ) : H5Object()
+DataType::DataType(const H5T_class_t type_class, size_t size) : H5Object()
 {
-   // Call C routine to create the new datatype
-   id = H5Tcreate( type_class, size );
-   if( id < 0 )
-   {
-      throw DataTypeIException("DataType constructor", "H5Tcreate failed");
-   }
+    // Call C routine to create the new datatype
+    id = H5Tcreate(type_class, size);
+    if(id < 0)
+    {
+        throw DataTypeIException("DataType constructor", "H5Tcreate failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -152,7 +152,7 @@ DataType::DataType(const DataType& original) : H5Object(), id(original.id)
 DataType::DataType(const PredType& pred_type) : H5Object()
 {
     // call C routine to copy the datatype
-    id = H5Tcopy( pred_type.getId() );
+    id = H5Tcopy(pred_type.getId());
     if (id < 0)
         throw DataTypeIException("DataType constructor", "H5Tcopy failed");
 }
@@ -169,7 +169,7 @@ DataType::DataType(const PredType& pred_type) : H5Object()
 //              - Replaced decRefCount with close() to let the C library
 //              handle the reference counting - BMR, Jun 1, 2006
 //--------------------------------------------------------------------------
-void DataType::copy( const DataType& like_type )
+void DataType::copy(const DataType& like_type)
 {
     // close the current data type before copying like_type to this object
     try {
@@ -180,8 +180,8 @@ void DataType::copy( const DataType& like_type )
     }
 
     // call C routine to copy the datatype
-    id = H5Tcopy( like_type.getId() );
-    if( id < 0 )
+    id = H5Tcopy(like_type.getId());
+    if(id < 0)
         throw DataTypeIException(inMemFunc("copy"), "H5Tcopy failed");
 }
 
@@ -205,8 +205,8 @@ void DataType::copy(const DataSet& dset)
     }
 
     // call C routine to copy the datatype
-    id = H5Tcopy( dset.getId() );
-    if( id < 0 )
+    id = H5Tcopy(dset.getId());
+    if(id < 0)
         throw DataTypeIException(inMemFunc("copy"), "H5Tcopy failed");
 }
 
@@ -229,7 +229,7 @@ void DataType::copy(const DataSet& dset)
 //              transient datatype.
 //              BMR - Mar, 2015
 //--------------------------------------------------------------------------
-DataType& DataType::operator=( const DataType& rhs )
+DataType& DataType::operator=(const DataType& rhs)
 {
     if (this != &rhs)
     {
@@ -247,19 +247,19 @@ DataType& DataType::operator=( const DataType& rhs )
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-bool DataType::operator==(const DataType& compared_type ) const
+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(inMemFunc("operator=="), "H5Tequal returns negative value");
-   }
+    // 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(inMemFunc("operator=="), "H5Tequal returns negative value");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -278,10 +278,10 @@ bool DataType::operator==(const DataType& compared_type ) const
 //--------------------------------------------------------------------------
 void DataType::p_commit(hid_t loc_id, const char* name)
 {
-   // Call C routine to commit the transient datatype
-   herr_t ret_value = H5Tcommit2(loc_id, name, id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-   if( ret_value < 0 )
-      throw DataTypeIException(inMemFunc("p_commit"), "H5Tcommit2 failed");
+    // Call C routine to commit the transient datatype
+    herr_t ret_value = H5Tcommit2(loc_id, name, id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    if(ret_value < 0)
+        throw DataTypeIException(inMemFunc("p_commit"), "H5Tcommit2 failed");
 }
 
 //--------------------------------------------------------------------------
@@ -295,7 +295,7 @@ void DataType::p_commit(hid_t loc_id, const char* name)
 //--------------------------------------------------------------------------
 void DataType::commit(const H5Location& loc, const char* name)
 {
-   p_commit(loc.getId(), name);
+    p_commit(loc.getId(), name);
 }
 
 //--------------------------------------------------------------------------
@@ -326,7 +326,7 @@ void DataType::commit(const H5Location& loc, const char* name)
 //--------------------------------------------------------------------------
 void DataType::commit(const H5Location& loc, const H5std_string& name)
 {
-   p_commit(loc.getId(), name.c_str());
+    p_commit(loc.getId(), name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -359,16 +359,16 @@ void DataType::commit(const H5Location& loc, const H5std_string& name)
 //--------------------------------------------------------------------------
 bool DataType::committed() const
 {
-   // Call C function to determine if a datatype is a named one
-   htri_t is_committed = H5Tcommitted( id );
-   if (is_committed > 0)
-      return true;
-   else if (is_committed == 0)
-      return false;
-   else
-   {
-      throw DataTypeIException(inMemFunc("committed"), "H5Tcommitted return negative value");
-   }
+    // Call C function to determine if a datatype is a named one
+    htri_t is_committed = H5Tcommitted(id);
+    if (is_committed > 0)
+        return true;
+    else if (is_committed == 0)
+        return false;
+    else
+    {
+        throw DataTypeIException(inMemFunc("committed"), "H5Tcommitted return negative value");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -381,15 +381,15 @@ bool DataType::committed() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5T_conv_t DataType::find( const DataType& dest, H5T_cdata_t **pcdata ) const
+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(inMemFunc("find"), "H5Tfind returns a NULL function");
-   }
-   return( func );
+    // Call C routine to find the conversion function
+    H5T_conv_t func = H5Tfind(id, dest.getId(), pcdata);
+    if(func == NULL)
+    {
+        throw DataTypeIException(inMemFunc("find"), "H5Tfind returns a NULL function");
+    }
+    return(func);
 }
 
 //--------------------------------------------------------------------------
@@ -405,19 +405,19 @@ H5T_conv_t DataType::find( const DataType& dest, H5T_cdata_t **pcdata ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::convert( const DataType& dest, size_t nelmts, void *buf, void *background, const PropList& plist ) const
+void DataType::convert(const DataType& dest, size_t nelmts, void *buf, void *background, const PropList& plist) const
 {
-   // Get identifiers for C API
-   hid_t dest_id = dest.getId();
-   hid_t plist_id = plist.getId();
+    // 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(inMemFunc("convert"), "H5Tconvert failed");
-   }
+    // 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(inMemFunc("convert"), "H5Tconvert failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -436,12 +436,12 @@ void DataType::convert( const DataType& dest, size_t nelmts, void *buf, void *ba
 //--------------------------------------------------------------------------
 void DataType::lock() const
 {
-   // Call C routine to lock the datatype
-   herr_t ret_value = H5Tlock( id );
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException(inMemFunc("lock"), "H5Tlock failed");
-   }
+    // Call C routine to lock the datatype
+    herr_t ret_value = H5Tlock(id);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("lock"), "H5Tlock failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -453,14 +453,14 @@ void DataType::lock() const
 //--------------------------------------------------------------------------
 H5T_class_t DataType::getClass() const
 {
-   H5T_class_t type_class = H5Tget_class( id );
+    H5T_class_t type_class = H5Tget_class(id);
 
-   // Return datatype class identifier if successful
-   if( type_class == H5T_NO_CLASS )
-   {
-      throw DataTypeIException(inMemFunc("getClass"), "H5Tget_class returns H5T_NO_CLASS");
-   }
-   return( type_class );
+    // Return datatype class identifier if successful
+    if(type_class == H5T_NO_CLASS)
+    {
+        throw DataTypeIException(inMemFunc("getClass"), "H5Tget_class returns H5T_NO_CLASS");
+    }
+    return(type_class);
 }
 
 //--------------------------------------------------------------------------
@@ -472,13 +472,13 @@ H5T_class_t DataType::getClass() const
 //--------------------------------------------------------------------------
 size_t DataType::getSize() const
 {
-   // Call C routine to get the datatype size
-   size_t type_size = H5Tget_size( id );
-   if( type_size <= 0 ) // valid data types are never zero size
-   {
-      throw DataTypeIException(inMemFunc("getSize"), "H5Tget_size returns invalid datatype size");
-   }
-   return( type_size );
+    // Call C routine to get the datatype size
+    size_t type_size = H5Tget_size(id);
+    if(type_size <= 0) // valid data types are never zero size
+    {
+        throw DataTypeIException(inMemFunc("getSize"), "H5Tget_size returns invalid datatype size");
+    }
+    return(type_size);
 }
 
 //--------------------------------------------------------------------------
@@ -490,22 +490,22 @@ size_t DataType::getSize() const
 //--------------------------------------------------------------------------
 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 );
+    // 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 )
-   {
+    // 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.p_setId(base_type_id);
         return(base_type);
-   }
-   else
-   {
-      throw DataTypeIException(inMemFunc("getSuper"), "H5Tget_super failed");
-   }
+    }
+    else
+    {
+        throw DataTypeIException(inMemFunc("getSuper"), "H5Tget_super failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -524,16 +524,16 @@ DataType DataType::getSuper() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5T.html#Datatype-Register
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::registerFunc( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const
+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
+    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(inMemFunc("registerFunc"), "H5Tregister failed");
-   }
+    // 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(inMemFunc("registerFunc"), "H5Tregister failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -543,9 +543,9 @@ void DataType::registerFunc( H5T_pers_t pers, const char* name, const DataType&
 ///             argument \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::registerFunc( H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func ) const
+void DataType::registerFunc(H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func) const
 {
-   registerFunc( pers, name.c_str(), dest, func );
+    registerFunc(pers, name.c_str(), dest, func);
 }
 
 //--------------------------------------------------------------------------
@@ -561,16 +561,16 @@ void DataType::registerFunc( H5T_pers_t pers, const H5std_string& name, const Da
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const
+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
+    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(inMemFunc("unregister"), "H5Tunregister failed");
-   }
+    // 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(inMemFunc("unregister"), "H5Tunregister failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -580,9 +580,9 @@ void DataType::unregister( H5T_pers_t pers, const char* name, const DataType& de
 ///             argument \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::unregister( H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func ) const
+void DataType::unregister(H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func) const
 {
-   unregister( pers, name.c_str(), dest, func );
+    unregister(pers, name.c_str(), dest, func);
 }
 
 //--------------------------------------------------------------------------
@@ -593,14 +593,14 @@ void DataType::unregister( H5T_pers_t pers, const H5std_string& name, const Data
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::setTag( const char* tag ) const
+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(inMemFunc("setTag"), "H5Tset_tag failed");
-   }
+    // Call C routine H5Tset_tag to tag an opaque datatype.
+    herr_t ret_value = H5Tset_tag(id, tag);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException(inMemFunc("setTag"), "H5Tset_tag failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -610,9 +610,9 @@ void DataType::setTag( const char* tag ) const
 ///             argument \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataType::setTag( const H5std_string& tag ) const
+void DataType::setTag(const H5std_string& tag) const
 {
-   setTag( tag.c_str());
+    setTag(tag.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -624,11 +624,11 @@ void DataType::setTag( const H5std_string& tag ) const
 //--------------------------------------------------------------------------
 H5std_string DataType::getTag() const
 {
-    char* tag_Cstr = H5Tget_tag( id );
+    char* tag_Cstr = H5Tget_tag(id);
 
     // if the tag C-string returned is not NULL, convert it to C++ string
     // and return it, otherwise, raise an exception
-    if( tag_Cstr != NULL )
+    if(tag_Cstr != NULL)
     {
         H5std_string tag = H5std_string(tag_Cstr); // C string to string object
         H5free_memory(tag_Cstr); // free the C string
@@ -651,16 +651,16 @@ H5std_string DataType::getTag() const
 //--------------------------------------------------------------------------
 bool DataType::detectClass(H5T_class_t cls) const
 {
-   htri_t ret_value = H5Tdetect_class(id, cls);
-   if( ret_value > 0 )
-      return true;
-   else if( ret_value == 0 )
-      return false;
-   else
-   {
-      throw DataTypeIException(inMemFunc("detectClass"),
+    htri_t ret_value = H5Tdetect_class(id, cls);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else
+    {
+        throw DataTypeIException(inMemFunc("detectClass"),
                                 "H5Tdetect_class returns negative value");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -673,16 +673,16 @@ bool DataType::detectClass(H5T_class_t cls) const
 //--------------------------------------------------------------------------
 bool DataType::isVariableStr() const
 {
-   htri_t is_varlen_str = H5Tis_variable_str(id);
-   if( is_varlen_str == 1 )
-      return true;
-   else if( is_varlen_str == 0 )
-      return false;
-   else
-   {
-      throw DataTypeIException(inMemFunc("isVariableStr"),
+    htri_t is_varlen_str = H5Tis_variable_str(id);
+    if(is_varlen_str == 1)
+        return true;
+    else if(is_varlen_str == 0)
+        return false;
+    else
+    {
+        throw DataTypeIException(inMemFunc("isVariableStr"),
                                 "H5Tis_variable_str returns negative value");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -699,7 +699,7 @@ bool DataType::isVariableStr() const
 //--------------------------------------------------------------------------
 hid_t DataType::getId() const
 {
-   return(id);
+    return(id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -724,8 +724,8 @@ void DataType::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw DataTypeIException(inMemFunc("p_setId"), close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -741,7 +741,7 @@ void DataType::close()
     if (p_valid_id(id))
     {
         herr_t ret_value = H5Tclose(id);
-        if( ret_value < 0 )
+        if(ret_value < 0)
         {
             throw DataTypeIException(inMemFunc("close"), "H5Tclose failed");
         }
diff --git a/c++/src/H5DataType.h b/c++/src/H5DataType.h
index 3ae97dc..6f796b8 100644
--- a/c++/src/H5DataType.h
+++ b/c++/src/H5DataType.h
@@ -30,10 +30,10 @@ namespace H5 {
 class H5_DLLCPP DataType : public H5Object {
    public:
         // Creates a datatype given its class and size
-        DataType( const H5T_class_t type_class, size_t size );
+        DataType(const H5T_class_t type_class, size_t size);
 
         // Copy constructor: makes a copy of the original object
-        DataType( const DataType& original );
+        DataType(const DataType& original);
 
         // Creates a copy of a predefined type
         DataType(const PredType& pred_type);
@@ -69,16 +69,16 @@ class H5_DLLCPP DataType : public H5Object {
 
         // 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;
+        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, const PropList& plist=PropList::DEFAULT) const;
+        void convert(const DataType& dest, size_t nelmts, void *buf, void *background, const PropList& plist=PropList::DEFAULT) const;
 
         // Assignment operator
-        DataType& operator=( const DataType& rhs );
+        DataType& operator=(const DataType& rhs);
 
         // Determines whether two datatypes are the same.
-        bool operator==(const DataType& compared_type ) const;
+        bool operator==(const DataType& compared_type) const;
 
         // Locks a datatype.
         void lock() const;
@@ -91,16 +91,16 @@ class H5_DLLCPP DataType : public H5Object {
         DataType getSuper() const;
 
         // Registers a conversion function.
-        void registerFunc(H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
-        void registerFunc(H5T_pers_t pers, const H5std_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;
+        void registerFunc(H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func) const;
 
         // Removes a conversion function from all conversion paths.
-        void unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
-        void unregister( H5T_pers_t pers, const H5std_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;
+        void unregister(H5T_pers_t pers, const H5std_string& name, const DataType& dest, H5T_conv_t func) const;
 
         // Tags an opaque datatype.
-        void setTag( const char* tag ) const;
-        void setTag( const H5std_string& tag ) const;
+        void setTag(const char* tag) const;
+        void setTag(const H5std_string& tag) const;
 
         // Gets the tag associated with an opaque datatype.
         H5std_string getTag() const;
@@ -115,7 +115,7 @@ class H5_DLLCPP DataType : public H5Object {
         virtual H5std_string fromClass () const { return("DataType"); }
 
         // Creates a copy of an existing DataType using its id
-        DataType( const hid_t type_id );
+        DataType(const hid_t type_id);
 
         // Default constructor
         DataType();
diff --git a/c++/src/H5DcreatProp.cpp b/c++/src/H5DcreatProp.cpp
index 0aa9a91..7f4bbf9 100644
--- a/c++/src/H5DcreatProp.cpp
+++ b/c++/src/H5DcreatProp.cpp
@@ -98,7 +98,7 @@ DSetCreatPropList::DSetCreatPropList() : ObjCreatPropList(H5P_DATASET_CREATE) {}
 ///             DSetCreatPropList object
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DSetCreatPropList::DSetCreatPropList( const DSetCreatPropList& orig ) : ObjCreatPropList(orig) {}
+DSetCreatPropList::DSetCreatPropList(const DSetCreatPropList& orig) : ObjCreatPropList(orig) {}
 
 //--------------------------------------------------------------------------
 // Function:    DSetCreatPropList overloaded constructor
@@ -123,13 +123,13 @@ DSetCreatPropList::DSetCreatPropList(const hid_t plist_id) : ObjCreatPropList(pl
 ///             changed to \c H5D_CHUNKED, if it is not so already.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::setChunk( int ndims, const hsize_t* dim ) const
+void DSetCreatPropList::setChunk(int ndims, const hsize_t* dim) const
 {
-   herr_t ret_value = H5Pset_chunk( id, ndims, dim );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setChunk", "H5Pset_chunk failed");
-   }
+    herr_t ret_value = H5Pset_chunk(id, ndims, dim);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setChunk", "H5Pset_chunk failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -141,15 +141,15 @@ void DSetCreatPropList::setChunk( int ndims, const hsize_t* dim ) const
 ///\exception   H5::PropListIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int DSetCreatPropList::getChunk( int max_ndims, hsize_t* dim ) const
+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("DSetCreatPropList::getChunk",
+    int chunk_size = H5Pget_chunk(id, max_ndims, dim);
+    if(chunk_size < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getChunk",
                 "H5Pget_chunk returns negative chunk size");
-   }
-   return( chunk_size );
+    }
+    return(chunk_size);
 }
 
 //--------------------------------------------------------------------------
@@ -164,12 +164,12 @@ int DSetCreatPropList::getChunk( int max_ndims, hsize_t* dim ) const
 //--------------------------------------------------------------------------
 void DSetCreatPropList::setLayout(H5D_layout_t layout) const
 {
-   herr_t ret_value = H5Pset_layout( id, layout );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setLayout",
+    herr_t ret_value = H5Pset_layout(id, layout);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setLayout",
                 "H5Pset_layout failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -190,13 +190,13 @@ void DSetCreatPropList::setLayout(H5D_layout_t layout) const
 //--------------------------------------------------------------------------
 H5D_layout_t DSetCreatPropList::getLayout() const
 {
-   H5D_layout_t layout = H5Pget_layout( id );
-   if( layout == H5D_LAYOUT_ERROR )
-   {
-      throw PropListIException("DSetCreatPropList::getLayout",
+    H5D_layout_t layout = H5Pget_layout(id);
+    if(layout == H5D_LAYOUT_ERROR)
+    {
+        throw PropListIException("DSetCreatPropList::getLayout",
                 "H5Pget_layout returns H5D_LAYOUT_ERROR");
-   }
-   return( layout );
+    }
+    return(layout);
 }
 
 //--------------------------------------------------------------------------
@@ -211,14 +211,14 @@ H5D_layout_t DSetCreatPropList::getLayout() const
 ///             less compression.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::setDeflate( int level ) const
+void DSetCreatPropList::setDeflate(int level) const
 {
-   herr_t ret_value = H5Pset_deflate( id, level );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setDeflate",
+    herr_t ret_value = H5Pset_deflate(id, level);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setDeflate",
                 "H5Pset_deflate failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -241,7 +241,7 @@ void DSetCreatPropList::setDeflate( int level ) const
 void DSetCreatPropList::setSzip(unsigned int options_mask, unsigned int pixels_per_block) const
 {
     herr_t ret_value = H5Pset_szip(id, options_mask, pixels_per_block);
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw PropListIException("DSetCreatPropList::setSzip",
                 "H5Pset_szip failed");
@@ -263,7 +263,7 @@ void DSetCreatPropList::setSzip(unsigned int options_mask, unsigned int pixels_p
 void DSetCreatPropList::setNbit() const
 {
     herr_t ret_value = H5Pset_nbit(id);
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw PropListIException("DSetCreatPropList::setNbit",
                 "H5Pset_nbit failed");
@@ -288,14 +288,14 @@ void DSetCreatPropList::setNbit() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetFillValue
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::setFillValue( const DataType& fvalue_type, const void* value ) const
+void DSetCreatPropList::setFillValue(const 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("DSetCreatPropList::setFillValue",
+    herr_t ret_value = H5Pset_fill_value(id, fvalue_type.getId(), value);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setFillValue",
                 "H5Pset_fill_value failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -311,14 +311,14 @@ void DSetCreatPropList::setFillValue( const DataType& fvalue_type, const void* v
 ///             specified by \a fvalue_type.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::getFillValue( const DataType& fvalue_type, void* value ) const
+void DSetCreatPropList::getFillValue(const DataType& fvalue_type, void* value) const
 {
-   herr_t ret_value = H5Pget_fill_value( id, fvalue_type.getId(), value );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::getFillValue",
+    herr_t ret_value = H5Pget_fill_value(id, fvalue_type.getId(), value);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getFillValue",
                 "H5Pget_fill_value failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -333,15 +333,15 @@ void DSetCreatPropList::getFillValue( const DataType& fvalue_type, void* value )
 //--------------------------------------------------------------------------
 H5D_fill_value_t DSetCreatPropList::isFillValueDefined() const
 {
-   H5D_fill_value_t status;
-   herr_t ret_value = H5Pfill_value_defined(id, &status);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::isFillValueDefined",
+    H5D_fill_value_t status;
+    herr_t ret_value = H5Pfill_value_defined(id, &status);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::isFillValueDefined",
                 "H5Pfill_value_defined returned H5D_FILL_VALUE_ERROR (-1)");
-   }
-   else
-      return (status);
+    }
+    else
+        return (status);
 }
 
 //--------------------------------------------------------------------------
@@ -364,15 +364,15 @@ H5D_fill_value_t DSetCreatPropList::isFillValueDefined() const
 ///             and the filter fails then the entire I/O operation fails.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::setFilter( H5Z_filter_t filter_id, unsigned int flags,
-        size_t cd_nelmts, const unsigned int cd_values[] ) const
+void DSetCreatPropList::setFilter(H5Z_filter_t filter_id, unsigned int flags,
+        size_t cd_nelmts, const unsigned int cd_values[]) const
 {
-   herr_t ret_value = H5Pset_filter( id, filter_id, flags, cd_nelmts, cd_values );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setFilter",
+    herr_t ret_value = H5Pset_filter(id, filter_id, flags, cd_nelmts, cd_values);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setFilter",
                 "H5Pset_filter failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -387,12 +387,12 @@ void DSetCreatPropList::setFilter( H5Z_filter_t filter_id, unsigned int flags,
 //--------------------------------------------------------------------------
 void DSetCreatPropList::removeFilter(H5Z_filter_t filter_id) const
 {
-   herr_t ret_value = H5Premove_filter( id, filter_id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::removeFilter",
+    herr_t ret_value = H5Premove_filter(id, filter_id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::removeFilter",
                 "H5Premove_filter failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -404,14 +404,14 @@ void DSetCreatPropList::removeFilter(H5Z_filter_t filter_id) const
 //--------------------------------------------------------------------------
 int DSetCreatPropList::getNfilters() const
 {
-   int num_filters = H5Pget_nfilters( id );
-   if( num_filters < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::getNfilters",
+    int num_filters = H5Pget_nfilters(id);
+    if(num_filters < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getNfilters",
                 "H5Pget_nfilters returned negative number of filters");
-   }
-   else
-      return( num_filters );
+    }
+    else
+        return(num_filters);
 }
 
 //--------------------------------------------------------------------------
@@ -438,14 +438,14 @@ H5Z_filter_t DSetCreatPropList::getFilter(int filter_number,
         unsigned int &flags, size_t &cd_nelmts, unsigned int* cd_values,
         size_t namelen, char name[], unsigned int& filter_config) const
 {
-   H5Z_filter_t filter_id;
-   filter_id = H5Pget_filter2(id, filter_number, &flags, &cd_nelmts,
+    H5Z_filter_t filter_id;
+    filter_id = H5Pget_filter2(id, filter_number, &flags, &cd_nelmts,
                                 cd_values, namelen, name, &filter_config);
-   if( filter_id == H5Z_FILTER_ERROR )
-      throw PropListIException("DSetCreatPropList::getFilter",
+    if(filter_id == H5Z_FILTER_ERROR)
+        throw PropListIException("DSetCreatPropList::getFilter",
                 "H5Pget_filter2 returned H5Z_FILTER_ERROR");
    else
-      return(filter_id);
+        return(filter_id);
 }
 
 //--------------------------------------------------------------------------
@@ -467,10 +467,10 @@ void DSetCreatPropList::getFilterById(H5Z_filter_t filter_id,
         unsigned int &flags, size_t &cd_nelmts, unsigned int* cd_values,
         size_t namelen, char name[], unsigned int &filter_config) const
 {
-   herr_t ret_value = H5Pget_filter_by_id2(id, filter_id, &flags, &cd_nelmts,
+    herr_t ret_value = H5Pget_filter_by_id2(id, filter_id, &flags, &cd_nelmts,
                                 cd_values, namelen, name, &filter_config);
-   if (ret_value < 0)
-      throw PropListIException("DSetCreatPropList::getFilterById",
+    if (ret_value < 0)
+        throw PropListIException("DSetCreatPropList::getFilterById",
                 "H5Pget_filter_by_id2 failed");
 }
 
@@ -495,15 +495,15 @@ void DSetCreatPropList::getFilterById(H5Z_filter_t filter_id,
 ///             and the filter fails then the entire I/O operation fails.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::modifyFilter( H5Z_filter_t filter_id, unsigned int
-        flags, size_t cd_nelmts, const unsigned int cd_values[] ) const
+void DSetCreatPropList::modifyFilter(H5Z_filter_t filter_id, unsigned int
+        flags, size_t cd_nelmts, const unsigned int cd_values[]) const
 {
-   herr_t ret_value = H5Pmodify_filter(id, filter_id, flags, cd_nelmts, cd_values);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::modifyFilter",
+    herr_t ret_value = H5Pmodify_filter(id, filter_id, flags, cd_nelmts, cd_values);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::modifyFilter",
                 "H5Pmodify_filter failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -517,15 +517,15 @@ void DSetCreatPropList::modifyFilter( H5Z_filter_t filter_id, unsigned int
 //--------------------------------------------------------------------------
 bool DSetCreatPropList::allFiltersAvail() const
 {
-   htri_t ret_value = H5Pall_filters_avail(id);
-   if( ret_value > 0 )
-      return true;
-   else if( ret_value == 0 )
-      return false;
-   else // Raise exception when H5Pall_filters_avail returns a negative value
-   {
-      throw PropListIException("DSetCreatPropList::allFiltersAvail", "H5Pall_filters_avail returned negative value");
-   }
+    htri_t ret_value = H5Pall_filters_avail(id);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else // Raise exception when H5Pall_filters_avail returns a negative value
+    {
+        throw PropListIException("DSetCreatPropList::allFiltersAvail", "H5Pall_filters_avail returned negative value");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -541,12 +541,12 @@ bool DSetCreatPropList::allFiltersAvail() const
 //--------------------------------------------------------------------------
 void DSetCreatPropList::setShuffle() const
 {
-   herr_t ret_value = H5Pset_shuffle(id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setShuffle",
+    herr_t ret_value = H5Pset_shuffle(id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setShuffle",
                 "H5Pset_shuffle failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -565,15 +565,15 @@ void DSetCreatPropList::setShuffle() const
 //--------------------------------------------------------------------------
 H5D_alloc_time_t DSetCreatPropList::getAllocTime() const
 {
-   H5D_alloc_time_t alloc_time;
-   herr_t ret_value = H5Pget_alloc_time(id, &alloc_time);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::getAllocTime",
+    H5D_alloc_time_t alloc_time;
+    herr_t ret_value = H5Pget_alloc_time(id, &alloc_time);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getAllocTime",
                 "H5Pget_alloc_time failed");
-   }
-   else
-      return (alloc_time);
+    }
+    else
+        return (alloc_time);
 }
 
 //--------------------------------------------------------------------------
@@ -589,15 +589,15 @@ H5D_alloc_time_t DSetCreatPropList::getAllocTime() const
 //--------------------------------------------------------------------------
 H5D_fill_time_t DSetCreatPropList::getFillTime() const
 {
-   H5D_fill_time_t fill_time;
-   herr_t ret_value = H5Pget_fill_time(id, &fill_time);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::getFillTime",
+    H5D_fill_time_t fill_time;
+    herr_t ret_value = H5Pget_fill_time(id, &fill_time);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getFillTime",
                 "H5Pget_fill_time failed");
-   }
-   else
-      return (fill_time);
+    }
+    else
+        return (fill_time);
 }
 
 //--------------------------------------------------------------------------
@@ -615,12 +615,12 @@ H5D_fill_time_t DSetCreatPropList::getFillTime() const
 //--------------------------------------------------------------------------
 void DSetCreatPropList::setAllocTime(H5D_alloc_time_t alloc_time) const
 {
-   herr_t ret_value = H5Pset_alloc_time(id, alloc_time);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setAllocTime",
+    herr_t ret_value = H5Pset_alloc_time(id, alloc_time);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setAllocTime",
                 "H5Pset_alloc_time failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -636,12 +636,12 @@ void DSetCreatPropList::setAllocTime(H5D_alloc_time_t alloc_time) const
 //--------------------------------------------------------------------------
 void DSetCreatPropList::setFillTime(H5D_fill_time_t fill_time) const
 {
-   herr_t ret_value = H5Pset_fill_time(id, fill_time);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setFillTime",
+    herr_t ret_value = H5Pset_fill_time(id, fill_time);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setFillTime",
                 "H5Pset_fill_time failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -653,12 +653,12 @@ void DSetCreatPropList::setFillTime(H5D_fill_time_t fill_time) const
 //--------------------------------------------------------------------------
 void DSetCreatPropList::setFletcher32() const
 {
-   herr_t ret_value = H5Pset_fletcher32(id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::setFletcher32",
+    herr_t ret_value = H5Pset_fletcher32(id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setFletcher32",
                 "H5Pset_fletcher32 failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -677,14 +677,14 @@ void DSetCreatPropList::setFletcher32() const
 ///             the extending).
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::setExternal( const char* name, off_t offset, hsize_t size ) const
+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("DSetCreatPropList::setExternal",
+    herr_t ret_value = H5Pset_external(id, name, offset, size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::setExternal",
                 "H5Pset_external failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -696,14 +696,14 @@ void DSetCreatPropList::setExternal( const char* name, off_t offset, hsize_t siz
 //--------------------------------------------------------------------------
 int DSetCreatPropList::getExternalCount() const
 {
-   int num_ext_files = H5Pget_external_count( id );
-   if( num_ext_files < 0 )
-   {
-      throw PropListIException("DSetCreatPropList::getExternalCount",
+    int num_ext_files = H5Pget_external_count(id);
+    if(num_ext_files < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getExternalCount",
                 "H5Pget_external_count returns negative number of external files");
-   }
-   else
-      return( num_ext_files );
+    }
+    else
+        return(num_ext_files);
 }
 
 //--------------------------------------------------------------------------
@@ -728,14 +728,14 @@ int DSetCreatPropList::getExternalCount() const
 ///             will not be returned.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetCreatPropList::getExternal( unsigned idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const
+void DSetCreatPropList::getExternal(unsigned 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("DSetCreatPropList::getExternal",
+    herr_t ret_value = H5Pget_external(id, idx, name_size, name, &offset, &size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetCreatPropList::getExternal",
                 "H5Pget_external failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5DcreatProp.h b/c++/src/H5DcreatProp.h
index ca99ca4..90b7ed7 100644
--- a/c++/src/H5DcreatProp.h
+++ b/c++/src/H5DcreatProp.h
@@ -43,13 +43,13 @@ class H5_DLLCPP DSetCreatPropList : public ObjCreatPropList {
         void setAllocTime(H5D_alloc_time_t alloc_time) const;
 
         // Retrieves the size of the chunks used to store a chunked layout dataset.
-        int getChunk( int max_ndims, hsize_t* dim ) const;
+        int getChunk(int max_ndims, hsize_t* dim) const;
 
         // Sets the size of the chunks used to store a chunked layout dataset.
-        void setChunk( int ndims, const hsize_t* dim ) const;
+        void setChunk(int ndims, const hsize_t* dim) const;
 
         // Returns information about an external file.
-        void getExternal( unsigned idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const;
+        void getExternal(unsigned idx, size_t name_size, char* name, off_t& offset, hsize_t& size) const;
 
         // Returns the number of external files for a dataset.
         int getExternalCount() const;
@@ -61,10 +61,10 @@ class H5_DLLCPP DSetCreatPropList : public ObjCreatPropList {
         void setFillTime(H5D_fill_time_t fill_time) const;
 
         // Retrieves a dataset fill value.
-        void getFillValue( const DataType& fvalue_type, void* value ) const;
+        void getFillValue(const DataType& fvalue_type, void* value) const;
 
         // Sets a dataset fill value.
-        void setFillValue( const DataType& fvalue_type, const void* value ) const;
+        void setFillValue(const DataType& fvalue_type, const void* value) 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[], unsigned int &filter_config) const;
@@ -87,19 +87,19 @@ class H5_DLLCPP DSetCreatPropList : public ObjCreatPropList {
         H5D_fill_value_t isFillValueDefined() const;
 
         // Modifies the specified filter.
-        void modifyFilter( H5Z_filter_t filter_id, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const;
+        void modifyFilter(H5Z_filter_t filter_id, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[]) const;
 
         // Remove one or all filters from the filter pipeline.
-        void removeFilter( H5Z_filter_t filter_id) const;
+        void removeFilter(H5Z_filter_t filter_id) const;
 
         // Sets compression method and compression level.
-        void setDeflate( int level ) const;
+        void setDeflate(int level) const;
 
         // Adds an external file to the list of external files.
-        void setExternal( const char* name, off_t offset, hsize_t size ) const;
+        void setExternal(const char* name, off_t offset, hsize_t size) const;
 
         // Adds a filter to the filter pipeline.
-        void setFilter( H5Z_filter_t filter, unsigned int flags = 0, size_t cd_nelmts = 0, const unsigned int cd_values[] = NULL) const;
+        void setFilter(H5Z_filter_t filter, unsigned int flags = 0, size_t cd_nelmts = 0, const unsigned int cd_values[] = NULL) const;
 
         // Sets Fletcher32 checksum of EDC for this property list.
         void setFletcher32() const;
diff --git a/c++/src/H5DxferProp.cpp b/c++/src/H5DxferProp.cpp
index 7d45b24..e1c5964 100644
--- a/c++/src/H5DxferProp.cpp
+++ b/c++/src/H5DxferProp.cpp
@@ -109,7 +109,7 @@ DSetMemXferPropList::DSetMemXferPropList(const char* exp) : PropList(H5P_DATASET
 ///                             list object to copy
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DSetMemXferPropList::DSetMemXferPropList(const DSetMemXferPropList& original ) : PropList( original ) {}
+DSetMemXferPropList::DSetMemXferPropList(const DSetMemXferPropList& original) : PropList(original) {}
 
 //--------------------------------------------------------------------------
 // Function     DSetMemXferPropList overloaded constructor
@@ -130,14 +130,14 @@ DSetMemXferPropList::DSetMemXferPropList(const hid_t plist_id) : PropList(plist_
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::setBuffer( size_t size, void* tconv, void* bkg ) const
+void DSetMemXferPropList::setBuffer(size_t size, void* tconv, void* bkg) const
 {
-   herr_t ret_value = H5Pset_buffer( id, size, tconv, bkg );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::setBuffer",
+    herr_t ret_value = H5Pset_buffer(id, size, tconv, bkg);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setBuffer",
                 "H5Pset_buffer failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -149,15 +149,15 @@ void DSetMemXferPropList::setBuffer( size_t size, void* tconv, void* bkg ) const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-size_t DSetMemXferPropList::getBuffer( void** tconv, void** bkg ) const
+size_t DSetMemXferPropList::getBuffer(void** tconv, void** bkg) const
 {
-   size_t buffer_size = H5Pget_buffer( id, tconv, bkg );
-   if( buffer_size == 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::getBuffer",
+    size_t buffer_size = H5Pget_buffer(id, tconv, bkg);
+    if(buffer_size == 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getBuffer",
                 "H5Pget_buffer returned 0 for buffer size - failure");
-   }
-   return( buffer_size );
+    }
+    return(buffer_size);
 }
 
 //--------------------------------------------------------------------------
@@ -167,14 +167,14 @@ size_t DSetMemXferPropList::getBuffer( void** tconv, void** bkg ) const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::setPreserve( bool status ) const
+void DSetMemXferPropList::setPreserve(bool status) const
 {
-   herr_t ret_value = H5Pset_preserve( id, (hbool_t) status );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::setPreserve",
+    herr_t ret_value = H5Pset_preserve(id, (hbool_t) status);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setPreserve",
                 "H5Pset_preserve failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -186,16 +186,16 @@ void DSetMemXferPropList::setPreserve( bool status ) const
 //--------------------------------------------------------------------------
 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("DSetMemXferPropList::getPreserve",
+    int ret_value = H5Pget_preserve(id);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else
+    {
+        throw PropListIException("DSetMemXferPropList::getPreserve",
                 "H5Pget_preserve returned negative value for status");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -207,14 +207,14 @@ bool DSetMemXferPropList::getPreserve() const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::setBtreeRatios( double left, double middle, double right ) const
+void DSetMemXferPropList::setBtreeRatios(double left, double middle, double right) const
 {
-   herr_t ret_value = H5Pset_btree_ratios( id, left, middle, right );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::setBtreeRatios",
+    herr_t ret_value = H5Pset_btree_ratios(id, left, middle, right);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setBtreeRatios",
                 "H5Pset_btree_ratios failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -226,14 +226,14 @@ void DSetMemXferPropList::setBtreeRatios( double left, double middle, double rig
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::getBtreeRatios( double& left, double& middle, double& right ) const
+void DSetMemXferPropList::getBtreeRatios(double& left, double& middle, double& right) const
 {
-   herr_t ret_value = H5Pget_btree_ratios( id, &left, &middle, &right );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::getBtreeRatios",
+    herr_t ret_value = H5Pget_btree_ratios(id, &left, &middle, &right);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getBtreeRatios",
                 "H5Pget_btree_ratios failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -245,12 +245,12 @@ void DSetMemXferPropList::getBtreeRatios( double& left, double& middle, double&
 //--------------------------------------------------------------------------
 void DSetMemXferPropList::setDataTransform(const char* expression) const
 {
-   herr_t ret_value = H5Pset_data_transform( id, expression);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::setDataTransform",
+    herr_t ret_value = H5Pset_data_transform(id, expression);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setDataTransform",
                 "H5Pset_data_transform failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -349,14 +349,14 @@ H5std_string DSetMemXferPropList::getDataTransform() const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - April, 2004
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::setTypeConvCB( H5T_conv_except_func_t op, void *user_data) const
+void DSetMemXferPropList::setTypeConvCB(H5T_conv_except_func_t op, void *user_data) const
 {
-   herr_t ret_value = H5Pset_type_conv_cb( id, op, user_data);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::setTypeConvCB",
+    herr_t ret_value = H5Pset_type_conv_cb(id, op, user_data);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setTypeConvCB",
                 "H5Pset_type_conv_cb failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -367,14 +367,14 @@ void DSetMemXferPropList::setTypeConvCB( H5T_conv_except_func_t op, void *user_d
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - April, 2004
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::getTypeConvCB( H5T_conv_except_func_t *op, void **user_data) const
+void DSetMemXferPropList::getTypeConvCB(H5T_conv_except_func_t *op, void **user_data) const
 {
-   herr_t ret_value = H5Pget_type_conv_cb( id, op, user_data);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::getTypeConvCB",
+    herr_t ret_value = H5Pget_type_conv_cb(id, op, user_data);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getTypeConvCB",
                 "H5Pget_type_conv_cb failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -387,15 +387,15 @@ void DSetMemXferPropList::getTypeConvCB( H5T_conv_except_func_t *op, void **user
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::setVlenMemManager( H5MM_allocate_t alloc_func, void* alloc_info, H5MM_free_t free_func, void* free_info ) const
+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("DSetMemXferPropList::setVlenMemManager",
+    herr_t ret_value = H5Pset_vlen_mem_manager(id, alloc_func, alloc_info,
+                                                free_func, free_info);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setVlenMemManager",
                 "H5Pset_vlen_mem_manager failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -408,7 +408,7 @@ void DSetMemXferPropList::setVlenMemManager( H5MM_allocate_t alloc_func, void* a
 //--------------------------------------------------------------------------
 void DSetMemXferPropList::setVlenMemManager() const
 {
-   setVlenMemManager( NULL, NULL, NULL, NULL );
+    setVlenMemManager(NULL, NULL, NULL, NULL);
 }
 
 //--------------------------------------------------------------------------
@@ -421,14 +421,14 @@ void DSetMemXferPropList::setVlenMemManager() const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DSetMemXferPropList::getVlenMemManager( H5MM_allocate_t& alloc_func, void** alloc_info, H5MM_free_t& free_func, void** free_info ) const
+void DSetMemXferPropList::getVlenMemManager(H5MM_allocate_t& alloc_func, void** alloc_info, H5MM_free_t& free_func, void** free_info) const
 {
-   herr_t ret_value = H5Pget_vlen_mem_manager( id, &alloc_func, alloc_info, &free_func, free_info );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("DSetMemXferPropList::getVlenMemManager",
+    herr_t ret_value = H5Pget_vlen_mem_manager(id, &alloc_func, alloc_info, &free_func, free_info);
+    if(ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getVlenMemManager",
                 "H5Pget_vlen_mem_manager failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -443,12 +443,12 @@ void DSetMemXferPropList::getVlenMemManager( H5MM_allocate_t& alloc_func, void**
 //--------------------------------------------------------------------------
 void DSetMemXferPropList::setSmallDataBlockSize(hsize_t size) const
 {
-   herr_t ret_value = H5Pset_small_data_block_size(id, size);
-   if (ret_value < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::setSmallDataBlockSize",
+    herr_t ret_value = H5Pset_small_data_block_size(id, size);
+    if (ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setSmallDataBlockSize",
                 "H5Pset_small_data_block_size failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -460,14 +460,14 @@ void DSetMemXferPropList::setSmallDataBlockSize(hsize_t size) const
 //--------------------------------------------------------------------------
 hsize_t DSetMemXferPropList::getSmallDataBlockSize() const
 {
-   hsize_t size;
-   herr_t ret_value = H5Pget_small_data_block_size(id, &size);
-   if (ret_value < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::getSmallDataBlockSize",
+    hsize_t size;
+    herr_t ret_value = H5Pget_small_data_block_size(id, &size);
+    if (ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getSmallDataBlockSize",
                 "H5Pget_small_data_block_size failed");
-   }
-   return(size);
+    }
+    return(size);
 }
 
 //--------------------------------------------------------------------------
@@ -483,12 +483,12 @@ hsize_t DSetMemXferPropList::getSmallDataBlockSize() const
 //--------------------------------------------------------------------------
 void DSetMemXferPropList::setHyperVectorSize(size_t vector_size) const
 {
-   herr_t ret_value = H5Pset_hyper_vector_size(id, vector_size);
-   if (ret_value < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::setHyperVectorSize",
+    herr_t ret_value = H5Pset_hyper_vector_size(id, vector_size);
+    if (ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setHyperVectorSize",
                 "H5Pset_hyper_vector_size failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -501,14 +501,14 @@ void DSetMemXferPropList::setHyperVectorSize(size_t vector_size) const
 //--------------------------------------------------------------------------
 size_t DSetMemXferPropList::getHyperVectorSize() const
 {
-   size_t vector_size;
-   herr_t ret_value = H5Pget_hyper_vector_size(id, &vector_size);
-   if (ret_value < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::getHyperVectorSize",
+    size_t vector_size;
+    herr_t ret_value = H5Pget_hyper_vector_size(id, &vector_size);
+    if (ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getHyperVectorSize",
                 "H5Pget_hyper_vector_size failed");
-   }
-   return(vector_size);
+    }
+    return(vector_size);
 }
 
 //--------------------------------------------------------------------------
@@ -531,12 +531,12 @@ size_t DSetMemXferPropList::getHyperVectorSize() const
 //--------------------------------------------------------------------------
 void DSetMemXferPropList::setEDCCheck(H5Z_EDC_t check) const
 {
-   herr_t ret_value = H5Pset_edc_check(id, check);
-   if (ret_value < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::setEDCCheck",
+    herr_t ret_value = H5Pset_edc_check(id, check);
+    if (ret_value < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::setEDCCheck",
                 "H5Pset_edc_check failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -548,13 +548,13 @@ void DSetMemXferPropList::setEDCCheck(H5Z_EDC_t check) const
 //--------------------------------------------------------------------------
 H5Z_EDC_t DSetMemXferPropList::getEDCCheck() const
 {
-   H5Z_EDC_t check = H5Pget_edc_check(id);
-   if (check < 0)
-   {
-      throw PropListIException("DSetMemXferPropList::getEDCCheck",
+    H5Z_EDC_t check = H5Pget_edc_check(id);
+    if (check < 0)
+    {
+        throw PropListIException("DSetMemXferPropList::getEDCCheck",
                 "H5Pget_edc_check failed");
-   }
-   return(check);
+    }
+    return(check);
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5DxferProp.h b/c++/src/H5DxferProp.h
index 72b64a16..0429508 100644
--- a/c++/src/H5DxferProp.h
+++ b/c++/src/H5DxferProp.h
@@ -36,16 +36,16 @@ class H5_DLLCPP DSetMemXferPropList : public PropList {
         DSetMemXferPropList(const char* expression);
 
         // Sets type conversion and background buffers.
-        void setBuffer( size_t size, void* tconv, void* bkg ) const;
+        void setBuffer(size_t size, void* tconv, void* bkg) const;
 
         // Reads buffer settings.
-        size_t getBuffer( void** tconv, void** bkg ) const;
+        size_t getBuffer(void** tconv, void** bkg) const;
 
         // Sets B-tree split ratios for a dataset transfer property list.
-        void setBtreeRatios( double left, double middle, double right ) const;
+        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;
+        void getBtreeRatios(double& left, double& middle, double& right) const;
 
         // Sets data transform expression.
         void setDataTransform(const char* expression) const;
@@ -56,21 +56,21 @@ class H5_DLLCPP DSetMemXferPropList : public PropList {
         H5std_string getDataTransform() const;
 
         // Sets the dataset transfer property list status to TRUE or FALSE.
-        void setPreserve( bool status ) const;
+        void setPreserve(bool status) const;
 
         // Checks status of the dataset transfer property list.
         bool getPreserve() const;
 
         // Sets an exception handling callback for datatype conversion.
-        void setTypeConvCB( H5T_conv_except_func_t op, void *user_data) const;
+        void setTypeConvCB(H5T_conv_except_func_t op, void *user_data) const;
 
         // Gets the exception handling callback for datatype conversion.
-        void getTypeConvCB( H5T_conv_except_func_t *op, void **user_data) const;
+        void getTypeConvCB(H5T_conv_except_func_t *op, void **user_data) const;
 
         // Sets the memory manager for variable-length datatype
         // allocation in H5Dread and H5Dvlen_reclaim.
-        void setVlenMemManager( H5MM_allocate_t alloc, void* alloc_info,
-                                H5MM_free_t free, void* free_info ) const;
+        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.
@@ -78,8 +78,8 @@ class H5_DLLCPP DSetMemXferPropList : public PropList {
 
         // 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;
+        void getVlenMemManager(H5MM_allocate_t& alloc, void** alloc_info,
+                                H5MM_free_t& free, void** free_info) const;
 
         // Sets the size of a contiguous block reserved for small data.
         void setSmallDataBlockSize(hsize_t size) const;
diff --git a/c++/src/H5EnumType.cpp b/c++/src/H5EnumType.cpp
index 8f7e911..14a6f43 100644
--- a/c++/src/H5EnumType.cpp
+++ b/c++/src/H5EnumType.cpp
@@ -49,14 +49,14 @@ EnumType::EnumType() : DataType() {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType::EnumType( const hid_t existing_id ) : DataType( existing_id ) {}
+EnumType::EnumType(const hid_t existing_id) : DataType(existing_id) {}
 
 //--------------------------------------------------------------------------
 // Function:    EnumType copy constructor
 ///\brief       Copy constructor: makes a copy of the original EnumType object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType::EnumType( const EnumType& original ) : DataType( original ) {}
+EnumType::EnumType(const EnumType& original) : DataType(original) {}
 
 //--------------------------------------------------------------------------
 // Function:    EnumType overloaded constructor
@@ -68,7 +68,7 @@ EnumType::EnumType( const EnumType& original ) : DataType( original ) {}
 //              the enum datatype.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType::EnumType( size_t size ) : DataType( H5T_ENUM, size ) {}
+EnumType::EnumType(size_t size) : DataType(H5T_ENUM, size) {}
 
 //--------------------------------------------------------------------------
 // Function:    EnumType overloaded constructor
@@ -77,16 +77,16 @@ EnumType::EnumType( size_t size ) : DataType( H5T_ENUM, size ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType::EnumType( const DataSet& dataset ) : DataType()
+EnumType::EnumType(const DataSet& dataset) : DataType()
 {
-   // Calls C function H5Dget_type to get the id of the datatype
-   id = H5Dget_type( dataset.getId() );
+    // 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("EnumType constructor", "H5Dget_type failed");
-   }
+    // If the datatype id is not valid, throw an exception
+    if(id < 0)
+    {
+        throw DataSetIException("EnumType constructor", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -96,16 +96,16 @@ EnumType::EnumType( const DataSet& dataset ) : DataType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-EnumType::EnumType( const IntType& data_type ) : 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() );
+    // 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("EnumType constructor", "H5Tenum_create failed");
-   }
+    // If the datatype id is not valid, throw an exception
+    if(id < 0)
+    {
+        throw DataSetIException("EnumType constructor", "H5Tenum_create failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -116,14 +116,14 @@ EnumType::EnumType( const IntType& data_type ) : DataType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void EnumType::insert( const char* name, void *value ) const
+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("EnumType::insert", "H5Tenum_insert failed");
-   }
+    // 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("EnumType::insert", "H5Tenum_insert failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -133,9 +133,9 @@ void EnumType::insert( const char* name, void *value ) const
 ///             argument \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void EnumType::insert( const H5std_string& name, void *value ) const
+void EnumType::insert(const H5std_string& name, void *value) const
 {
-    insert( name.c_str(), value );
+    insert(name.c_str(), value);
 }
 
 //--------------------------------------------------------------------------
@@ -147,24 +147,24 @@ void EnumType::insert( const H5std_string& name, void *value ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string EnumType::nameOf( void *value, size_t size ) const
+H5std_string EnumType::nameOf(void *value, size_t size) const
 {
-   char* name_C = new char[size+1];  // temporary C-string for C API
-   HDmemset(name_C, 0, size+1); // clear buffer
+    char* name_C = new char[size+1];  // temporary C-string for C API
+    HDmemset(name_C, 0, size+1); // clear buffer
 
-   // 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 );
+    // 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 )
-   {
+    // If H5Tenum_nameof returns a negative value, raise an exception,
+    if(ret_value < 0)
+    {
       delete []name_C;
-      throw DataTypeIException("EnumType::nameOf", "H5Tenum_nameof failed");
-   }
-   // otherwise, create the string to hold the datatype name and return it
-   H5std_string name(name_C);
-   delete []name_C;
-   return( name );
+        throw DataTypeIException("EnumType::nameOf", "H5Tenum_nameof failed");
+    }
+    // otherwise, create the string to hold the datatype name and return it
+    H5std_string name(name_C);
+    delete []name_C;
+    return(name);
 }
 
 //--------------------------------------------------------------------------
@@ -176,14 +176,14 @@ H5std_string EnumType::nameOf( void *value, size_t size ) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void EnumType::valueOf( const char* name, void *value ) const
+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("EnumType::valueOf", "H5Tenum_valueof failed");
-   }
+    herr_t ret_value = H5Tenum_valueof(id, name, value);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("EnumType::valueOf", "H5Tenum_valueof failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -193,9 +193,9 @@ void EnumType::valueOf( const char* name, void *value ) const
 ///             argument \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void EnumType::valueOf( const H5std_string& name, void *value ) const
+void EnumType::valueOf(const H5std_string& name, void *value) const
 {
-    valueOf( name.c_str(), value );
+    valueOf(name.c_str(), value);
 }
 
 //--------------------------------------------------------------------------
@@ -210,13 +210,13 @@ void EnumType::valueOf( const H5std_string& name, void *value ) const
 //--------------------------------------------------------------------------
 int EnumType::getMemberIndex(const char *name) const
 {
-   int member_index = H5Tget_member_index(id, name);
-   if( member_index < 0 )
-   {
-      throw DataTypeIException("EnumType::getMemberIndex",
+    int member_index = H5Tget_member_index(id, name);
+    if(member_index < 0)
+    {
+        throw DataTypeIException("EnumType::getMemberIndex",
                 "H5Tget_member_index returns negative value");
-   }
-   return( member_index );
+    }
+    return(member_index);
 }
 
 //--------------------------------------------------------------------------
@@ -240,13 +240,13 @@ int EnumType::getMemberIndex(const H5std_string& name) const
 //--------------------------------------------------------------------------
 int EnumType::getNmembers() const
 {
-   int num_members = H5Tget_nmembers( id );
-   if( num_members < 0 )
-   {
-      throw DataTypeIException("EnumType::getNmembers",
+    int num_members = H5Tget_nmembers(id);
+    if(num_members < 0)
+    {
+        throw DataTypeIException("EnumType::getNmembers",
                 "H5Tget_nmembers returns negative number of members");
-   }
-   return( num_members );
+    }
+    return(num_members);
 }
 
 //--------------------------------------------------------------------------
@@ -258,14 +258,14 @@ int EnumType::getNmembers() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void EnumType::getMemberValue( unsigned memb_no, void *value ) const
+void EnumType::getMemberValue(unsigned 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("EnumType::getMemberValue", "H5Tget_member_value failed");
-   }
+    // 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("EnumType::getMemberValue", "H5Tget_member_value failed");
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5EnumType.h b/c++/src/H5EnumType.h
index 7f10d15..949c75d 100644
--- a/c++/src/H5EnumType.h
+++ b/c++/src/H5EnumType.h
@@ -29,13 +29,13 @@ class H5_DLLCPP 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 );
+        EnumType(size_t size);
 
         // Gets the enum datatype of the specified dataset
-        EnumType( const DataSet& dataset );  // H5Dget_type
+        EnumType(const DataSet& dataset);  // H5Dget_type
 
         // Creates a new enum datatype based on an integer datatype
-        EnumType( const IntType& data_type );  // H5Tenum_create
+        EnumType(const IntType& data_type);  // H5Tenum_create
 
         // Returns the number of members in this enumeration datatype.
         int getNmembers () const;
@@ -45,20 +45,20 @@ class H5_DLLCPP EnumType : public DataType {
         int getMemberIndex(const H5std_string& name) const;
 
         // Returns the value of an enumeration datatype member
-        void getMemberValue( unsigned memb_no, void *value ) const;
+        void getMemberValue(unsigned memb_no, void *value) const;
 
         // Inserts a new member to this enumeration type.
-        void insert( const char* name, void *value ) const;
-        void insert( const H5std_string& name, void *value ) const;
+        void insert(const char* name, void *value) const;
+        void insert(const H5std_string& name, void *value) const;
 
         // Returns the symbol name corresponding to a specified member
         // of this enumeration datatype.
-        H5std_string nameOf( void *value, size_t size ) const;
+        H5std_string nameOf(void *value, size_t size) const;
 
         // Returns the value corresponding to a specified member of this
         // enumeration datatype.
-        void valueOf( const char* name, void *value ) const;
-        void valueOf( const H5std_string& name, void *value ) const;
+        void valueOf(const char* name, void *value) const;
+        void valueOf(const H5std_string& name, void *value) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("EnumType"); }
@@ -67,10 +67,10 @@ class H5_DLLCPP EnumType : public DataType {
         EnumType();
 
         // Creates an enumeration datatype using an existing id
-        EnumType( const hid_t existing_id );
+        EnumType(const hid_t existing_id);
 
         // Copy constructor: makes a copy of the original EnumType object.
-        EnumType( const EnumType& original );
+        EnumType(const EnumType& original);
 
         virtual ~EnumType();
 
diff --git a/c++/src/H5Exception.cpp b/c++/src/H5Exception.cpp
index ecc50d2..ebb7d62 100644
--- a/c++/src/H5Exception.cpp
+++ b/c++/src/H5Exception.cpp
@@ -45,7 +45,7 @@ Exception::Exception(const H5std_string& func, const H5std_string& message) : de
 ///\param       orig - IN: Exception instance to copy
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Exception::Exception( const Exception& orig ) : detail_message(orig.detail_message), func_name(orig.func_name) {}
+Exception::Exception(const Exception& orig) : detail_message(orig.detail_message), func_name(orig.func_name) {}
 
 //--------------------------------------------------------------------------
 // Function:    Exception::getMajorString
@@ -58,32 +58,32 @@ Exception::Exception( const Exception& orig ) : detail_message(orig.detail_messa
 ///             will be returned.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string Exception::getMajorString( hid_t err_major ) const
+H5std_string Exception::getMajorString(hid_t err_major) const
 {
-   // Preliminary call to H5Eget_msg() to get the length of the message
-   ssize_t mesg_size = H5Eget_msg(err_major, NULL, NULL, 0);
+    // Preliminary call to H5Eget_msg() to get the length of the message
+    ssize_t mesg_size = H5Eget_msg(err_major, NULL, NULL, 0);
 
-   // If H5Eget_msg() returns a negative value, raise an exception,
-   if( mesg_size < 0 )
-      throw IdComponentException("Exception::getMajorString",
+    // If H5Eget_msg() returns a negative value, raise an exception,
+    if(mesg_size < 0)
+        throw IdComponentException("Exception::getMajorString",
                                 "H5Eget_msg failed");
 
-   // Call H5Eget_msg again to get the actual message
-   char* mesg_C = new char[mesg_size+1];  // temporary C-string for C API
-   mesg_size = H5Eget_msg(err_major, NULL, mesg_C, mesg_size+1);
+    // Call H5Eget_msg again to get the actual message
+    char* mesg_C = new char[mesg_size+1];  // temporary C-string for C API
+    mesg_size = H5Eget_msg(err_major, NULL, mesg_C, mesg_size+1);
 
-   // Check for failure again
-   if( mesg_size < 0 )
-   {
-      delete []mesg_C;
-      throw IdComponentException("Exception::getMajorString",
+    // Check for failure again
+    if(mesg_size < 0)
+    {
+        delete []mesg_C;
+        throw IdComponentException("Exception::getMajorString",
                                 "H5Eget_msg failed");
-   }
+    }
 
-   // Convert the C error description and return
-   H5std_string major_str(mesg_C);
-   delete []mesg_C;
-   return( major_str );
+    // Convert the C error description and return
+    H5std_string major_str(mesg_C);
+    delete []mesg_C;
+    return(major_str);
 }
 
 //--------------------------------------------------------------------------
@@ -97,32 +97,32 @@ H5std_string Exception::getMajorString( hid_t err_major ) const
 ///             will be returned.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5std_string Exception::getMinorString( hid_t err_minor ) const
+H5std_string Exception::getMinorString(hid_t err_minor) const
 {
-   // Preliminary call to H5Eget_msg() to get the length of the message
-   ssize_t mesg_size = H5Eget_msg(err_minor, NULL, NULL, 0);
+    // Preliminary call to H5Eget_msg() to get the length of the message
+    ssize_t mesg_size = H5Eget_msg(err_minor, NULL, NULL, 0);
 
-   // If H5Eget_msg() returns a negative value, raise an exception,
-   if( mesg_size < 0 )
-      throw IdComponentException("Exception::getMinorString",
+    // If H5Eget_msg() returns a negative value, raise an exception,
+    if(mesg_size < 0)
+        throw IdComponentException("Exception::getMinorString",
                                 "H5Eget_msg failed");
 
-   // Call H5Eget_msg again to get the actual message
-   char* mesg_C = new char[mesg_size+1];  // temporary C-string for C API
-   mesg_size = H5Eget_msg(err_minor, NULL, mesg_C, mesg_size+1);
+    // Call H5Eget_msg again to get the actual message
+    char* mesg_C = new char[mesg_size+1];  // temporary C-string for C API
+    mesg_size = H5Eget_msg(err_minor, NULL, mesg_C, mesg_size+1);
 
-   // Check for failure again
-   if( mesg_size < 0 )
-   {
-      delete []mesg_C;
-      throw IdComponentException("Exception::getMinorString",
+    // Check for failure again
+    if(mesg_size < 0)
+    {
+        delete []mesg_C;
+        throw IdComponentException("Exception::getMinorString",
                                 "H5Eget_msg failed");
-   }
+    }
 
-   // Convert the C error description and return
-   H5std_string minor_str(mesg_C);
-   delete []mesg_C;
-   return( minor_str );
+    // Convert the C error description and return
+    H5std_string minor_str(mesg_C);
+    delete []mesg_C;
+    return(minor_str);
 }
 
 //--------------------------------------------------------------------------
@@ -141,13 +141,13 @@ H5std_string Exception::getMinorString( hid_t err_minor ) const
 ///             handlers
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void Exception::setAutoPrint( H5E_auto2_t& func, void* client_data )
+void Exception::setAutoPrint(H5E_auto2_t& func, void* client_data)
 {
-   // calls the C API routine H5Eset_auto to set the auto printing to
-   // the specified function.
-   herr_t ret_value = H5Eset_auto2( H5E_DEFAULT, func, client_data );
-   if( ret_value < 0 )
-      throw Exception( "Exception::setAutoPrint", "H5Eset_auto failed" );
+    // calls the C API routine H5Eset_auto to set the auto printing to
+    // the specified function.
+    herr_t ret_value = H5Eset_auto2(H5E_DEFAULT, func, client_data);
+    if(ret_value < 0)
+        throw Exception("Exception::setAutoPrint", "H5Eset_auto failed");
 }
 
 //--------------------------------------------------------------------------
@@ -157,11 +157,11 @@ void Exception::setAutoPrint( H5E_auto2_t& func, void* client_data )
 //--------------------------------------------------------------------------
 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_auto2( H5E_DEFAULT, NULL, NULL );
-   if( ret_value < 0 )
-      throw Exception( "Exception::dontPrint", "H5Eset_auto failed" );
+    // calls the C API routine H5Eset_auto with NULL parameters to turn
+    // off the automatic error printing.
+    herr_t ret_value = H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
+    if(ret_value < 0)
+        throw Exception("Exception::dontPrint", "H5Eset_auto failed");
 }
 
 //--------------------------------------------------------------------------
@@ -174,13 +174,13 @@ void Exception::dontPrint()
 ///                                     the error function
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void Exception::getAutoPrint( H5E_auto2_t& func, void** client_data )
+void Exception::getAutoPrint(H5E_auto2_t& func, void** client_data)
 {
-   // calls the C API routine H5Eget_auto to get the current setting of
-   // the automatic error printing
-   herr_t ret_value = H5Eget_auto2( H5E_DEFAULT, &func, client_data );
-   if( ret_value < 0 )
-      throw Exception( "Exception::getAutoPrint", "H5Eget_auto failed" );
+    // calls the C API routine H5Eget_auto to get the current setting of
+    // the automatic error printing
+    herr_t ret_value = H5Eget_auto2(H5E_DEFAULT, &func, client_data);
+    if(ret_value < 0)
+        throw Exception("Exception::getAutoPrint", "H5Eget_auto failed");
 }
 
 //--------------------------------------------------------------------------
@@ -193,10 +193,10 @@ void Exception::getAutoPrint( H5E_auto2_t& func, void** client_data )
 //--------------------------------------------------------------------------
 void Exception::clearErrorStack()
 {
-   // calls the C API routine H5Eclear to clear the error stack
-   herr_t ret_value = H5Eclear2(H5E_DEFAULT);
-   if( ret_value < 0 )
-      throw Exception( "Exception::clearErrorStack", "H5Eclear failed" );
+    // calls the C API routine H5Eclear to clear the error stack
+    herr_t ret_value = H5Eclear2(H5E_DEFAULT);
+    if(ret_value < 0)
+        throw Exception("Exception::clearErrorStack", "H5Eclear failed");
 }
 
 //--------------------------------------------------------------------------
@@ -240,12 +240,12 @@ void Exception::clearErrorStack()
 ///\endcode
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void Exception::walkErrorStack( H5E_direction_t direction, H5E_walk2_t func, void* client_data )
+void Exception::walkErrorStack(H5E_direction_t direction, H5E_walk2_t func, void* client_data)
 {
-   // calls the C API routine H5Ewalk to walk the error stack
-   herr_t ret_value = H5Ewalk2( H5E_DEFAULT, direction, func, client_data );
-   if( ret_value < 0 )
-      throw Exception( "Exception::walkErrorStack", "H5Ewalk failed" );
+    // calls the C API routine H5Ewalk to walk the error stack
+    herr_t ret_value = H5Ewalk2(H5E_DEFAULT, direction, func, client_data);
+    if(ret_value < 0)
+        throw Exception("Exception::walkErrorStack", "H5Ewalk failed");
 }
 
 //--------------------------------------------------------------------------
@@ -257,7 +257,7 @@ void Exception::walkErrorStack( H5E_direction_t direction, H5E_walk2_t func, voi
 //--------------------------------------------------------------------------
 H5std_string Exception::getDetailMsg() const
 {
-   return(detail_message);
+    return(detail_message);
 }
 
 //--------------------------------------------------------------------------
@@ -269,7 +269,7 @@ H5std_string Exception::getDetailMsg() const
 //--------------------------------------------------------------------------
 const char* Exception::getCDetailMsg() const
 {
-   return(detail_message.c_str());
+    return(detail_message.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -280,7 +280,7 @@ const char* Exception::getCDetailMsg() const
 //--------------------------------------------------------------------------
 H5std_string Exception::getFuncName() const
 {
-   return(func_name);
+    return(func_name);
 }
 
 //--------------------------------------------------------------------------
@@ -291,7 +291,7 @@ H5std_string Exception::getFuncName() const
 //--------------------------------------------------------------------------
 const char* Exception::getCFuncName() const
 {
-   return(func_name.c_str());
+    return(func_name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -304,8 +304,8 @@ const char* Exception::getCFuncName() const
 void Exception::printErrorStack(FILE* stream, hid_t err_stack)
 {
     herr_t ret_value = H5Eprint2(err_stack, stream);
-    if( ret_value < 0 )
-        throw Exception( "Printing error stack", "H5Eprint2 failed" );
+    if(ret_value < 0)
+        throw Exception("Printing error stack", "H5Eprint2 failed");
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5Exception.h b/c++/src/H5Exception.h
index e5f4eab..fd67118 100644
--- a/c++/src/H5Exception.h
+++ b/c++/src/H5Exception.h
@@ -39,11 +39,11 @@ class H5_DLLCPP Exception {
 
         // Returns a character string that describes the error specified by
         // a major error number.
-        H5std_string getMajorString( hid_t err_major_id ) const;
+        H5std_string getMajorString(hid_t err_major_id) const;
 
         // Returns a character string that describes the error specified by
         // a minor error number.
-        H5std_string getMinorString( hid_t err_minor_id ) const;
+        H5std_string getMinorString(hid_t err_minor_id) const;
 
         // Returns the detailed message set at the time the exception is thrown
         H5std_string getDetailMsg() const;
@@ -52,21 +52,21 @@ class H5_DLLCPP Exception {
         const char* getCFuncName() const;       // function name as a char string
 
         // Turns on the automatic error printing.
-        static void setAutoPrint( H5E_auto2_t& func, void* client_data);
+        static void setAutoPrint(H5E_auto2_t& func, void* client_data);
 
         // Turns off the automatic error printing.
         static void dontPrint();
 
         // Retrieves the current settings for the automatic error stack
         // traversal function and its data.
-        static void getAutoPrint( H5E_auto2_t& func, void** client_data);
+        static void getAutoPrint(H5E_auto2_t& func, void** client_data);
 
         // Clears the error stack for the current thread.
         static void clearErrorStack();
 
         // Walks the error stack for the current thread, calling the
         // specified function.
-        static void walkErrorStack( H5E_direction_t direction,
+        static void walkErrorStack(H5E_direction_t direction,
                                 H5E_walk2_t func, void* client_data);
 
         // Prints the error stack in a default manner.
@@ -78,7 +78,7 @@ class H5_DLLCPP Exception {
         Exception();
 
         // copy constructor
-        Exception( const Exception& orig);
+        Exception(const Exception& orig);
 
         // virtual Destructor
         virtual ~Exception() throw();
@@ -94,14 +94,14 @@ class H5_DLLCPP Exception {
 
 class H5_DLLCPP FileIException : public Exception {
    public:
-        FileIException( const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
+        FileIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
         FileIException();
         virtual ~FileIException() throw();
 };
 
 class H5_DLLCPP GroupIException : public Exception {
    public:
-        GroupIException( const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
+        GroupIException(const H5std_string& func_name, const H5std_string& message = DEFAULT_MSG);
         GroupIException();
         virtual ~GroupIException() throw();
 };
diff --git a/c++/src/H5FaccProp.cpp b/c++/src/H5FaccProp.cpp
index 548d9d9..76981e1 100644
--- a/c++/src/H5FaccProp.cpp
+++ b/c++/src/H5FaccProp.cpp
@@ -86,7 +86,7 @@ const FileAccPropList& FileAccPropList::DEFAULT = *getConstant();
 ///\brief       Creates a file access property list
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FileAccPropList::FileAccPropList() : PropList( H5P_FILE_ACCESS ) {}
+FileAccPropList::FileAccPropList() : PropList(H5P_FILE_ACCESS) {}
 
 //--------------------------------------------------------------------------
 // Function:    FileAccPropList copy constructor
@@ -113,11 +113,11 @@ FileAccPropList::FileAccPropList(const hid_t plist_id) : PropList(plist_id) {}
 //--------------------------------------------------------------------------
 void FileAccPropList::setStdio() const
 {
-   herr_t ret_value = H5Pset_fapl_stdio(id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setStdio", "H5Pset_fapl_stdio failed");
-   }
+    herr_t ret_value = H5Pset_fapl_stdio(id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setStdio", "H5Pset_fapl_stdio failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -133,12 +133,12 @@ void FileAccPropList::setStdio() const
 //--------------------------------------------------------------------------
 hid_t FileAccPropList::getDriver() const
 {
-   hid_t driver = H5Pget_driver(id);
-   if (driver < 0)
-   {
-      throw PropListIException("FileAccPropList::getDriver", "H5Pget_driver failed");
-   }
-   return(driver);
+    hid_t driver = H5Pget_driver(id);
+    if (driver < 0)
+    {
+        throw PropListIException("FileAccPropList::getDriver", "H5Pget_driver failed");
+    }
+    return(driver);
 }
 
 //--------------------------------------------------------------------------
@@ -155,11 +155,11 @@ hid_t FileAccPropList::getDriver() const
 //--------------------------------------------------------------------------
 void FileAccPropList::setDriver(hid_t new_driver_id, const void *new_driver_info) const
 {
-   herr_t ret_value = H5Pset_driver(id, new_driver_id, new_driver_info);
-   if (ret_value < 0)
-   {
-      throw PropListIException("FileAccPropList::setDriver", "H5Pset_driver failed");
-   }
+    herr_t ret_value = H5Pset_driver(id, new_driver_id, new_driver_info);
+    if (ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setDriver", "H5Pset_driver failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -171,11 +171,11 @@ void FileAccPropList::setDriver(hid_t new_driver_id, const void *new_driver_info
 //--------------------------------------------------------------------------
 void FileAccPropList::setFamilyOffset(hsize_t offset) const
 {
-   herr_t ret_value = H5Pset_family_offset(id, offset);
-   if (ret_value < 0)
-   {
-      throw PropListIException("FileAccPropList::setFamilyOffset", "H5Pset_family_offset failed");
-   }
+    herr_t ret_value = H5Pset_family_offset(id, offset);
+    if (ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setFamilyOffset", "H5Pset_family_offset failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -187,13 +187,13 @@ void FileAccPropList::setFamilyOffset(hsize_t offset) const
 //--------------------------------------------------------------------------
 hsize_t FileAccPropList::getFamilyOffset() const
 {
-   hsize_t offset;
-   herr_t ret_value = H5Pget_family_offset(id, &offset);
-   if (ret_value < 0)
-   {
-      throw PropListIException("FileAccPropList::getFamilyOffset", "H5Pget_family_offset failed");
-   }
-   return(offset);
+    hsize_t offset;
+    herr_t ret_value = H5Pget_family_offset(id, &offset);
+    if (ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getFamilyOffset", "H5Pget_family_offset failed");
+    }
+    return(offset);
 }
 
 //--------------------------------------------------------------------------
@@ -213,11 +213,11 @@ hsize_t FileAccPropList::getFamilyOffset() const
 //--------------------------------------------------------------------------
 void FileAccPropList::setCore (size_t increment, hbool_t backing_store) const
 {
-   herr_t ret_value = H5Pset_fapl_core (id, increment, backing_store);
-   if (ret_value < 0)
-   {
-      throw PropListIException ("FileAccPropList::setCore", "H5Pset_fapl_core failed");
-   }
+    herr_t ret_value = H5Pset_fapl_core (id, increment, backing_store);
+    if (ret_value < 0)
+    {
+        throw PropListIException ("FileAccPropList::setCore", "H5Pset_fapl_core failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -231,11 +231,11 @@ void FileAccPropList::setCore (size_t increment, hbool_t backing_store) const
 //--------------------------------------------------------------------------
 void FileAccPropList::getCore (size_t& increment, hbool_t& backing_store) const
 {
-   herr_t ret_value = H5Pget_fapl_core(id, &increment, &backing_store);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getCore", "H5Pget_fapl_core failed");
-   }
+    herr_t ret_value = H5Pget_fapl_core(id, &increment, &backing_store);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getCore", "H5Pget_fapl_core failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -249,13 +249,13 @@ void FileAccPropList::getCore (size_t& increment, hbool_t& backing_store) const
 ///             Note that \a memb_size is used only when creating a new file.
 // Programmer:  Binh-Minh Ribler - April, 2004
 //--------------------------------------------------------------------------
-void FileAccPropList::setFamily( hsize_t memb_size, const FileAccPropList& memb_plist ) const
+void FileAccPropList::setFamily(hsize_t memb_size, const FileAccPropList& memb_plist) const
 {
-   herr_t ret_value = H5Pset_fapl_family (id, memb_size, memb_plist.getId() );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setFamily", "H5Pset_fapl_family failed");
-   }
+    herr_t ret_value = H5Pset_fapl_family (id, memb_size, memb_plist.getId());
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setFamily", "H5Pset_fapl_family failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -270,12 +270,12 @@ void FileAccPropList::setFamily( hsize_t memb_size, const FileAccPropList& memb_
 //--------------------------------------------------------------------------
 void FileAccPropList::getFamily(hsize_t& memb_size, FileAccPropList& memb_plist) const
 {
-   hid_t memb_plist_id;
-   herr_t ret_value = H5Pget_fapl_family( id, &memb_size, &memb_plist_id );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getFamily", "H5Pget_fapl_family failed");
-   }
+    hid_t memb_plist_id;
+    herr_t ret_value = H5Pget_fapl_family(id, &memb_size, &memb_plist_id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getFamily", "H5Pget_fapl_family failed");
+    }
    memb_plist.p_setId(memb_plist_id);
 }
 
@@ -291,14 +291,14 @@ void FileAccPropList::getFamily(hsize_t& memb_size, FileAccPropList& memb_plist)
 //--------------------------------------------------------------------------
 FileAccPropList FileAccPropList::getFamily(hsize_t& memb_size) const
 {
-   hid_t memb_plist_id;
-   herr_t ret_value = H5Pget_fapl_family( id, &memb_size, &memb_plist_id );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getFamily", "H5Pget_fapl_family failed");
-   }
+    hid_t memb_plist_id;
+    herr_t ret_value = H5Pget_fapl_family(id, &memb_size, &memb_plist_id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getFamily", "H5Pget_fapl_family failed");
+    }
    FileAccPropList memb_plist(memb_plist_id);
-   return(memb_plist);
+    return(memb_plist);
 }
 
 //--------------------------------------------------------------------------
@@ -317,15 +317,15 @@ FileAccPropList FileAccPropList::getFamily(hsize_t& memb_size) const
 // Modification
 //              Replaced the version without const parameter - Apr, 2014
 //--------------------------------------------------------------------------
-void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const FileAccPropList& raw_plist, const char* meta_ext, const char* raw_ext ) const
+void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const 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_fapl_split( id, meta_ext, meta_pid, raw_ext, raw_pid );
-   if( ret_value < 0 )
+    hid_t meta_pid = meta_plist.getId();
+    hid_t raw_pid = raw_plist.getId();
+    herr_t ret_value = H5Pset_fapl_split(id, meta_ext, meta_pid, raw_ext, raw_pid);
+    if(ret_value < 0)
 {
-      throw PropListIException("FileAccPropList::setSplit", "H5Pset_fapl_split failed");
-   }
+        throw PropListIException("FileAccPropList::setSplit", "H5Pset_fapl_split failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -341,9 +341,9 @@ void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const FileAccP
 // Modification
 //              Replaced the version without const parameter - Apr, 2014
 //--------------------------------------------------------------------------
-void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const FileAccPropList& raw_plist, const H5std_string& meta_ext, const H5std_string& raw_ext ) const
+void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const FileAccPropList& raw_plist, const H5std_string& meta_ext, const H5std_string& raw_ext) const
 {
-   setSplit( meta_plist, raw_plist, meta_ext.c_str(), raw_ext.c_str() );
+    setSplit(meta_plist, raw_plist, meta_ext.c_str(), raw_ext.c_str());
 }
 
 // Stream Virtual File Driver had been removed from the main library.
@@ -360,13 +360,13 @@ void FileAccPropList::setSplit(const FileAccPropList& meta_plist, const FileAccP
 //--------------------------------------------------------------------------
 size_t FileAccPropList::getSieveBufSize() const
 {
-   size_t bufsize;
-   herr_t ret_value = H5Pget_sieve_buf_size(id, &bufsize);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getSieveBufSize", "H5Pget_sieve_buf_size failed");
-   }
-   return(bufsize);
+    size_t bufsize;
+    herr_t ret_value = H5Pget_sieve_buf_size(id, &bufsize);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getSieveBufSize", "H5Pget_sieve_buf_size failed");
+    }
+    return(bufsize);
 }
 
 //--------------------------------------------------------------------------
@@ -381,11 +381,11 @@ size_t FileAccPropList::getSieveBufSize() const
 //--------------------------------------------------------------------------
 void FileAccPropList::setSieveBufSize(size_t bufsize) const
 {
-   herr_t ret_value = H5Pset_sieve_buf_size(id, bufsize);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getSieveBufSize", "H5Pget_sieve_buf_size failed");
-   }
+    herr_t ret_value = H5Pset_sieve_buf_size(id, bufsize);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getSieveBufSize", "H5Pget_sieve_buf_size failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -401,11 +401,11 @@ void FileAccPropList::setSieveBufSize(size_t bufsize) const
 //--------------------------------------------------------------------------
 void FileAccPropList::setMetaBlockSize(hsize_t &block_size) const
 {
-   herr_t ret_value = H5Pset_meta_block_size(id, block_size);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setMetaBlockSize", "H5Pset_meta_block_size failed");
-   }
+    herr_t ret_value = H5Pset_meta_block_size(id, block_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setMetaBlockSize", "H5Pset_meta_block_size failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -417,13 +417,13 @@ void FileAccPropList::setMetaBlockSize(hsize_t &block_size) const
 //--------------------------------------------------------------------------
 hsize_t FileAccPropList::getMetaBlockSize() const
 {
-   hsize_t block_size;
-   herr_t ret_value = H5Pget_meta_block_size(id, &block_size);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getMetaBlockSize", "H5Pget_meta_block_size failed");
-   }
-   return(block_size);
+    hsize_t block_size;
+    herr_t ret_value = H5Pget_meta_block_size(id, &block_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getMetaBlockSize", "H5Pget_meta_block_size failed");
+    }
+    return(block_size);
 }
 
 //--------------------------------------------------------------------------
@@ -441,11 +441,11 @@ hsize_t FileAccPropList::getMetaBlockSize() const
 //--------------------------------------------------------------------------
 void FileAccPropList::setLog(const char *logfile, unsigned flags, size_t buf_size) const
 {
-   herr_t ret_value = H5Pset_fapl_log(id, logfile, flags, buf_size);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setLog", "H5Pset_fapl_log failed");
-   }
+    herr_t ret_value = H5Pset_fapl_log(id, logfile, flags, buf_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setLog", "H5Pset_fapl_log failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -460,7 +460,7 @@ void FileAccPropList::setLog(const char *logfile, unsigned flags, size_t buf_siz
 //--------------------------------------------------------------------------
 void FileAccPropList::setLog(const H5std_string& logfile, unsigned flags, size_t buf_size) const
 {
-   setLog(logfile.c_str(), flags, buf_size);
+    setLog(logfile.c_str(), flags, buf_size);
 }
 
 //--------------------------------------------------------------------------
@@ -473,11 +473,11 @@ void FileAccPropList::setLog(const H5std_string& logfile, unsigned flags, size_t
 //--------------------------------------------------------------------------
 void FileAccPropList::setSec2() const
 {
-   herr_t ret_value = H5Pset_fapl_sec2(id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setSec2", "H5Pset_fapl_sec2 failed");
-   }
+    herr_t ret_value = H5Pset_fapl_sec2(id);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setSec2", "H5Pset_fapl_sec2 failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -496,13 +496,13 @@ void FileAccPropList::setSec2() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetAlignment
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileAccPropList::setAlignment( hsize_t threshold, hsize_t alignment ) const
+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("FileAccPropList::setAlignment", "H5Pset_alignment failed");
-   }
+    herr_t ret_value = H5Pset_alignment(id, threshold, alignment);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setAlignment", "H5Pset_alignment failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -514,13 +514,13 @@ void FileAccPropList::setAlignment( hsize_t threshold, hsize_t alignment ) const
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileAccPropList::getAlignment( hsize_t &threshold, hsize_t &alignment ) const
+void FileAccPropList::getAlignment(hsize_t &threshold, hsize_t &alignment) const
 {
-   herr_t ret_value = H5Pget_alignment( id, &threshold, &alignment );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getAlignment", "H5Pget_alignment failed");
-   }
+    herr_t ret_value = H5Pget_alignment(id, &threshold, &alignment);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getAlignment", "H5Pget_alignment failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -535,11 +535,11 @@ void FileAccPropList::getAlignment( hsize_t &threshold, hsize_t &alignment ) con
 //--------------------------------------------------------------------------
 void FileAccPropList::setMultiType(H5FD_mem_t dtype) const
 {
-   herr_t ret_value = H5Pset_multi_type(id, dtype);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setMultiType", "H5Pset_multi_type failed");
-   }
+    herr_t ret_value = H5Pset_multi_type(id, dtype);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setMultiType", "H5Pset_multi_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -554,13 +554,13 @@ void FileAccPropList::setMultiType(H5FD_mem_t dtype) const
 //--------------------------------------------------------------------------
 H5FD_mem_t FileAccPropList::getMultiType() const
 {
-   H5FD_mem_t dtype;
-   herr_t ret_value = H5Pget_multi_type(id, &dtype);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getMultiType", "H5Pget_multi_type failed");
-   }
-   return(dtype);
+    H5FD_mem_t dtype;
+    herr_t ret_value = H5Pget_multi_type(id, &dtype);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getMultiType", "H5Pget_multi_type failed");
+    }
+    return(dtype);
 }
 
 //--------------------------------------------------------------------------
@@ -580,13 +580,13 @@ H5FD_mem_t FileAccPropList::getMultiType() const
 ///             means fully read chunks are always preempted before other chunks.
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileAccPropList::setCache( int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const
+void FileAccPropList::setCache(int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0) const
 {
-   herr_t ret_value = H5Pset_cache( id, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0 );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setCache", "H5Pset_cache failed");
-   }
+    herr_t ret_value = H5Pset_cache(id, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setCache", "H5Pset_cache failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -599,13 +599,13 @@ void FileAccPropList::setCache( int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_
 ///\exception   H5::PropListIException
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileAccPropList::getCache( int& mdc_nelmts, size_t& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const
+void FileAccPropList::getCache(int& mdc_nelmts, size_t& 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("FileAccPropList::getCache", "H5Pget_cache failed");
-   }
+    herr_t ret_value = H5Pget_cache(id, &mdc_nelmts, &rdcc_nelmts, &rdcc_nbytes, &rdcc_w0);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getCache", "H5Pget_cache failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -617,11 +617,11 @@ void FileAccPropList::getCache( int& mdc_nelmts, size_t& rdcc_nelmts, size_t& rd
 //--------------------------------------------------------------------------
 void FileAccPropList::setFcloseDegree(H5F_close_degree_t degree) const
 {
-   herr_t ret_value = H5Pset_fclose_degree(id, degree);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setFcloseDegree", "H5Pset_fclose_degree failed");
-   }
+    herr_t ret_value = H5Pset_fclose_degree(id, degree);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setFcloseDegree", "H5Pset_fclose_degree failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -633,13 +633,13 @@ void FileAccPropList::setFcloseDegree(H5F_close_degree_t degree) const
 //--------------------------------------------------------------------------
 H5F_close_degree_t FileAccPropList::getFcloseDegree() const
 {
-   H5F_close_degree_t degree;
-   herr_t ret_value = H5Pget_fclose_degree(id, &degree);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::getFcloseDegree", "H5Pget_fclose_degree failed");
-   }
-   return(degree);
+    H5F_close_degree_t degree;
+    herr_t ret_value = H5Pget_fclose_degree(id, &degree);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::getFcloseDegree", "H5Pget_fclose_degree failed");
+    }
+    return(degree);
 }
 
 //--------------------------------------------------------------------------
@@ -653,13 +653,13 @@ H5F_close_degree_t FileAccPropList::getFcloseDegree() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetGCReferences
 // Programmer:  Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileAccPropList::setGcReferences( unsigned gc_ref ) const
+void FileAccPropList::setGcReferences(unsigned gc_ref) const
 {
-   herr_t ret_value = H5Pset_gc_references( id, gc_ref );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileAccPropList::setGcReferences", "H5Pset_gc_references failed");
-   }
+    herr_t ret_value = H5Pset_gc_references(id, gc_ref);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileAccPropList::setGcReferences", "H5Pset_gc_references failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -671,15 +671,15 @@ void FileAccPropList::setGcReferences( unsigned gc_ref ) const
 //--------------------------------------------------------------------------
 unsigned FileAccPropList::getGcReferences() const
 {
-   unsigned gc_ref;
+    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("FileAccPropList::getGcReferences", "H5Pget_gc_references failed");
-   }
-   return( 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("FileAccPropList::getGcReferences", "H5Pget_gc_references failed");
+    }
+    return(gc_ref);
 }
 
 //--------------------------------------------------------------------------
@@ -737,7 +737,7 @@ void FileAccPropList::setLibverBounds(H5F_libver_t libver_low, H5F_libver_t libv
 void FileAccPropList::getLibverBounds(H5F_libver_t& libver_low, H5F_libver_t& libver_high) const
 {
     herr_t ret_value = H5Pget_libver_bounds(id, &libver_low, &libver_high);
-    if( ret_value < 0 )
+    if(ret_value < 0)
     {
         throw PropListIException("FileAccPropList::getLibverBounds", "H5Pget_libver_bounds failed");
     }
diff --git a/c++/src/H5FaccProp.h b/c++/src/H5FaccProp.h
index 272bf39..237dd68 100644
--- a/c++/src/H5FaccProp.h
+++ b/c++/src/H5FaccProp.h
@@ -58,7 +58,7 @@ class H5_DLLCPP FileAccPropList : public PropList {
         void getCore (size_t& increment, hbool_t& backing_store) const;
 
         // Sets this file access properties list to the family driver.
-        void setFamily( hsize_t memb_size, const FileAccPropList& memb_plist ) const;
+        void setFamily(hsize_t memb_size, const FileAccPropList& memb_plist) const;
 
         // Returns information about the family file access property list.
         void getFamily(hsize_t& memb_size, FileAccPropList& memb_plist) const;
@@ -68,7 +68,7 @@ class H5_DLLCPP FileAccPropList : public PropList {
         void setSplit(const FileAccPropList& meta_plist,
                       const FileAccPropList& raw_plist,
                       const char* meta_ext = ".meta",
-                      const char* raw_ext = ".raw" ) const;
+                      const char* raw_ext = ".raw") const;
         void setSplit(const FileAccPropList& meta_plist,
                       const FileAccPropList& raw_plist,
                       const H5std_string& meta_ext = ".meta",
@@ -92,11 +92,11 @@ class H5_DLLCPP FileAccPropList : public PropList {
         void setLog(const H5std_string& logfile, unsigned flags, size_t buf_size) const;
 
         // Sets alignment properties of this file access property list
-        void setAlignment( hsize_t threshold = 1, hsize_t alignment = 1 ) const;
+        void setAlignment(hsize_t threshold = 1, hsize_t alignment = 1) const;
 
         // Retrieves the current settings for alignment properties from
         // this property list.
-        void getAlignment( hsize_t& threshold, hsize_t& alignment ) const;
+        void getAlignment(hsize_t& threshold, hsize_t& alignment) const;
 
         // Sets data type for multi driver.
         void setMultiType(H5FD_mem_t dtype) const;
@@ -105,10 +105,10 @@ class H5_DLLCPP FileAccPropList : public PropList {
         H5FD_mem_t getMultiType() const;
 
         // Sets the meta data cache and raw data chunk cache parameters.
-        void setCache( int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const;
+        void setCache(int mdc_nelmts, size_t rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0) const;
 
         // Queries the meta data cache and raw data chunk cache parameters.
-        void getCache( int& mdc_nelmts, size_t& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const;
+        void getCache(int& mdc_nelmts, size_t& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0) const;
 
         // Sets the degree for the file close behavior.
         void setFcloseDegree(H5F_close_degree_t degree) const;
@@ -117,7 +117,7 @@ class H5_DLLCPP FileAccPropList : public PropList {
         H5F_close_degree_t getFcloseDegree() const;
 
         // Sets garbage collecting references flag.
-        void setGcReferences( unsigned gc_ref = 0 ) const;
+        void setGcReferences(unsigned gc_ref = 0) const;
 
         // Returns garbage collecting references setting.
         unsigned getGcReferences() const;
@@ -133,7 +133,7 @@ class H5_DLLCPP FileAccPropList : public PropList {
         virtual H5std_string fromClass () const { return("FileAccPropList"); }
 
         // Copy constructor: creates a copy of a FileAccPropList object.
-        FileAccPropList( const FileAccPropList& original );
+        FileAccPropList(const FileAccPropList& original);
 
         // Creates a copy of an existing file access property list
         // using the property list id.
diff --git a/c++/src/H5FcreatProp.cpp b/c++/src/H5FcreatProp.cpp
index 1da3aa8..117bf01 100644
--- a/c++/src/H5FcreatProp.cpp
+++ b/c++/src/H5FcreatProp.cpp
@@ -84,7 +84,7 @@ const FileCreatPropList& FileCreatPropList::DEFAULT = *getConstant();
 ///\brief       Default constructor: Creates a file create property list
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FileCreatPropList::FileCreatPropList() : PropList( H5P_FILE_CREATE ) {}
+FileCreatPropList::FileCreatPropList() : PropList(H5P_FILE_CREATE) {}
 
 //--------------------------------------------------------------------------
 // Function:    FileCreatPropList copy constructor
@@ -93,7 +93,7 @@ FileCreatPropList::FileCreatPropList() : PropList( H5P_FILE_CREATE ) {}
 ///\param       original - IN: FileCreatPropList instance to copy
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FileCreatPropList::FileCreatPropList( const FileCreatPropList& original ) : PropList( original ) {}
+FileCreatPropList::FileCreatPropList(const FileCreatPropList& original) : PropList(original) {}
 
 //--------------------------------------------------------------------------
 // Function:    FileCreatPropList overloaded constructor
@@ -118,12 +118,12 @@ FileCreatPropList::FileCreatPropList(const hid_t plist_id) : PropList(plist_id)
 //--------------------------------------------------------------------------
 void FileCreatPropList::getVersion(unsigned& super, unsigned& freelist, unsigned& stab, unsigned& shhdr) const
 {
-   herr_t ret_value = H5Pget_version( id, &super, &freelist, &stab, &shhdr );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::getVersion",
+    herr_t ret_value = H5Pget_version(id, &super, &freelist, &stab, &shhdr);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::getVersion",
                 "H5Pget_version failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -136,14 +136,14 @@ void FileCreatPropList::getVersion(unsigned& super, unsigned& freelist, unsigned
 ///             of 2 equal to 512 or greater (512, 1024, 2048, etc.)
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::setUserblock( hsize_t size ) const
+void FileCreatPropList::setUserblock(hsize_t size) const
 {
-   herr_t ret_value = H5Pset_userblock( id, size);
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::setUserblock",
+    herr_t ret_value = H5Pset_userblock(id, size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::setUserblock",
                 "H5Pset_userblock failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -155,14 +155,14 @@ void FileCreatPropList::setUserblock( hsize_t size ) const
 //--------------------------------------------------------------------------
 hsize_t FileCreatPropList::getUserblock() const
 {
-   hsize_t userblock_size;
-   herr_t ret_value = H5Pget_userblock( id, &userblock_size );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::getUserblock",
+    hsize_t userblock_size;
+    herr_t ret_value = H5Pget_userblock(id, &userblock_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::getUserblock",
                 "H5Pget_userblock failed");
-   }
-   return( userblock_size );
+    }
+    return(userblock_size);
 }
 
 //--------------------------------------------------------------------------
@@ -178,14 +178,14 @@ hsize_t FileCreatPropList::getUserblock() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetSizes
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::setSizes( size_t sizeof_addr, size_t sizeof_size ) const
+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("FileCreatPropList::setSizes",
+    herr_t ret_value = H5Pset_sizes(id, sizeof_addr, sizeof_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::setSizes",
                 "H5Pset_sizes failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -196,14 +196,14 @@ void FileCreatPropList::setSizes( size_t sizeof_addr, size_t sizeof_size ) const
 ///\exception   H5::PropListIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::getSizes( size_t& sizeof_addr, size_t& sizeof_size ) const
+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("FileCreatPropList::getSizes",
+    herr_t ret_value = H5Pget_sizes(id, &sizeof_addr, &sizeof_size);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::getSizes",
                 "H5Pget_sizes failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -218,14 +218,14 @@ void FileCreatPropList::getSizes( size_t& sizeof_addr, size_t& sizeof_size ) con
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetSymK
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::setSymk( unsigned ik, unsigned lk ) const
+void FileCreatPropList::setSymk(unsigned ik, unsigned lk) const
 {
-   herr_t ret_value = H5Pset_sym_k( id, ik, lk );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::setSymk",
+    herr_t ret_value = H5Pset_sym_k(id, ik, lk);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::setSymk",
                 "H5Pset_sym_k failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -239,14 +239,14 @@ void FileCreatPropList::setSymk( unsigned ik, unsigned lk ) const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-GetSymK
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::getSymk( unsigned& ik, unsigned& lk ) const
+void FileCreatPropList::getSymk(unsigned& ik, unsigned& lk) const
 {
-   herr_t ret_value = H5Pget_sym_k( id, &ik, &lk );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::getSymk",
+    herr_t ret_value = H5Pget_sym_k(id, &ik, &lk);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::getSymk",
                 "H5Pget_sym_k failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -260,14 +260,14 @@ void FileCreatPropList::getSymk( unsigned& ik, unsigned& lk ) const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetIstoreK
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FileCreatPropList::setIstorek( unsigned ik ) const
+void FileCreatPropList::setIstorek(unsigned ik) const
 {
-   herr_t ret_value = H5Pset_istore_k( id, ik );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::setIstorek",
+    herr_t ret_value = H5Pset_istore_k(id, ik);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::setIstorek",
                 "H5Pset_istore_k failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -282,14 +282,14 @@ void FileCreatPropList::setIstorek( unsigned ik ) const
 //--------------------------------------------------------------------------
 unsigned FileCreatPropList::getIstorek() const
 {
-   unsigned ik;
-   herr_t ret_value = H5Pget_istore_k( id, &ik );
-   if( ret_value < 0 )
-   {
-      throw PropListIException("FileCreatPropList::getIstorek",
+    unsigned ik;
+    herr_t ret_value = H5Pget_istore_k(id, &ik);
+    if(ret_value < 0)
+    {
+        throw PropListIException("FileCreatPropList::getIstorek",
                 "H5Pget_istore_k failed");
-   }
-   return( ik );
+    }
+    return(ik);
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5FcreatProp.h b/c++/src/H5FcreatProp.h
index 02eacbc..f50b4c6 100644
--- a/c++/src/H5FcreatProp.h
+++ b/c++/src/H5FcreatProp.h
@@ -33,34 +33,34 @@ class H5_DLLCPP FileCreatPropList : public PropList {
         FileCreatPropList();
 
         // Retrieves version information for various parts of a file.
-        void getVersion( unsigned& super, unsigned& freelist, unsigned& stab, unsigned& shhdr ) const;
+        void getVersion(unsigned& super, unsigned& freelist, unsigned& stab, unsigned& shhdr) const;
 
         // Sets the userblock size field of a file creation property list.
-        void setUserblock( hsize_t size ) const;
+        void setUserblock(hsize_t size) const;
 
         // Gets the size of a user block in this file creation property list.
         hsize_t getUserblock() 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;
+        void getSizes(size_t& sizeof_addr, size_t& sizeof_size) const;
 
         // Sets file size-of addresses and sizes.
-        void setSizes( size_t sizeof_addr = 4, size_t sizeof_size = 4 ) const;
+        void setSizes(size_t sizeof_addr = 4, size_t sizeof_size = 4) const;
 
         // Retrieves the size of the symbol table B-tree 1/2 rank and the
         // symbol table leaf node 1/2 size.
-        void getSymk( unsigned& int_nodes_k, unsigned& leaf_nodes_k ) const;
+        void getSymk(unsigned& int_nodes_k, unsigned& leaf_nodes_k) const;
 
         // Sets the size of parameters used to control the symbol table nodes.
-        void setSymk( unsigned int_nodes_k, unsigned leaf_nodes_k ) const;
+        void setSymk(unsigned int_nodes_k, unsigned leaf_nodes_k) const;
 
         // Returns the 1/2 rank of an indexed storage B-tree.
         unsigned getIstorek() const;
 
         // Sets the size of parameter used to control the B-trees for
         // indexing chunked datasets.
-        void setIstorek( unsigned ik ) const;
+        void setIstorek(unsigned ik) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("FileCreatPropList"); }
diff --git a/c++/src/H5File.cpp b/c++/src/H5File.cpp
index 9475da9..c18431c 100644
--- a/c++/src/H5File.cpp
+++ b/c++/src/H5File.cpp
@@ -82,7 +82,7 @@ H5File::H5File() : H5Location(), CommonFG(), id(H5I_INVALID_HID) {}
 //              to catch then re-throw it. -BMR 2013/03/21
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5File::H5File( const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist ) : H5Location(), CommonFG(), id(H5I_INVALID_HID)
+H5File::H5File(const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist) : H5Location(), CommonFG(), id(H5I_INVALID_HID)
 {
     try {
         p_get_file(name, flags, create_plist, access_plist);
@@ -107,7 +107,7 @@ H5File::H5File( const char* name, unsigned int flags, const FileCreatPropList& c
 //              to catch then re-throw it. -BMR 2013/03/21
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5File::H5File( const H5std_string& name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist ) : H5Location(), CommonFG(), id(H5I_INVALID_HID)
+H5File::H5File(const H5std_string& name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist) : H5Location(), CommonFG(), id(H5I_INVALID_HID)
 {
     try {
         p_get_file(name.c_str(), flags, create_plist, access_plist);
@@ -129,12 +129,12 @@ void H5File::p_get_file(const char* name, unsigned int flags, const FileCreatPro
 {
     // These bits only set for creation, so if any of them are set,
     // create the file.
-    if( flags & (H5F_ACC_EXCL|H5F_ACC_TRUNC))
+    if(flags & (H5F_ACC_EXCL|H5F_ACC_TRUNC))
     {
         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 );
-        if( id < 0 )  // throw an exception when open/create fail
+        id = H5Fcreate(name, flags, create_plist_id, access_plist_id);
+        if(id < 0)  // throw an exception when open/create fail
         {
             throw FileIException("H5File constructor", "H5Fcreate failed");
         }
@@ -143,8 +143,8 @@ void H5File::p_get_file(const char* name, unsigned int flags, const FileCreatPro
     else
     {
         hid_t access_plist_id = access_plist.getId();
-        id = H5Fopen( name, flags, access_plist_id );
-        if( id < 0 )  // throw an exception when open/create fail
+        id = H5Fopen(name, flags, access_plist_id);
+        if(id < 0)  // throw an exception when open/create fail
         {
             throw FileIException("H5File constructor", "H5Fopen failed");
         }
@@ -195,17 +195,17 @@ H5File::H5File(const H5File& original) : H5Location(), CommonFG()
 //--------------------------------------------------------------------------
 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("H5File::isHdf5", "H5Fis_hdf5 returned negative value");
-   }
+    // 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("H5File::isHdf5", "H5Fis_hdf5 returned negative value");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -215,9 +215,9 @@ bool H5File::isHdf5(const char* name)
 ///\param       name - IN: Name of the file - \c H5std_string
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-bool H5File::isHdf5(const H5std_string& name )
+bool H5File::isHdf5(const H5std_string& name)
 {
-   return( isHdf5( name.c_str()) );
+    return(isHdf5(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -296,11 +296,11 @@ void H5File::reOpen()
         throw FileIException("H5File::reOpen", close_error.getDetailMsg());
     }
 
-   // call C routine to reopen the file - Note: not sure about this,
-   // which id to be the parameter when closing?
-   id = H5Freopen( id );
-   if( id < 0 ) // Raise exception when H5Freopen returns a neg value
-      throw FileIException("H5File::reOpen", "H5Freopen failed");
+    // call C routine to reopen the file - Note: not sure about this,
+    // which id to be the parameter when closing?
+    id = H5Freopen(id);
+    if(id < 0) // Raise exception when H5Freopen returns a neg value
+        throw FileIException("H5File::reOpen", "H5Freopen failed");
 }
 
 //--------------------------------------------------------------------------
@@ -312,19 +312,19 @@ void H5File::reOpen()
 //--------------------------------------------------------------------------
 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("H5File::getCreatePlist", "H5Fget_create_plist failed");
-   }
+    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("H5File::getCreatePlist", "H5Fget_create_plist failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -336,19 +336,19 @@ FileCreatPropList H5File::getCreatePlist() const
 //--------------------------------------------------------------------------
 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("H5File::getAccessPlist", "H5Fget_access_plist failed");
-   }
+    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("H5File::getAccessPlist", "H5Fget_access_plist failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -360,12 +360,12 @@ FileAccPropList H5File::getAccessPlist() const
 //--------------------------------------------------------------------------
 hssize_t H5File::getFreeSpace() const
 {
-   hssize_t free_space = H5Fget_freespace(id);
-   if( free_space < 0 )
-   {
-      throw FileIException("H5File::getFreeSpace", "H5Fget_freespace failed");
-   }
-   return (free_space);
+    hssize_t free_space = H5Fget_freespace(id);
+    if(free_space < 0)
+    {
+        throw FileIException("H5File::getFreeSpace", "H5Fget_freespace failed");
+    }
+    return (free_space);
 }
 
 
@@ -392,12 +392,12 @@ hssize_t H5File::getFreeSpace() const
 //--------------------------------------------------------------------------
 ssize_t H5File::getObjCount(unsigned types) const
 {
-   ssize_t num_objs = H5Fget_obj_count(id, types);
-   if( num_objs < 0 )
-   {
-      throw FileIException("H5File::getObjCount", "H5Fget_obj_count failed");
-   }
-   return (num_objs);
+    ssize_t num_objs = H5Fget_obj_count(id, types);
+    if(num_objs < 0)
+    {
+        throw FileIException("H5File::getObjCount", "H5Fget_obj_count failed");
+    }
+    return (num_objs);
 }
 
 //--------------------------------------------------------------------------
@@ -427,11 +427,11 @@ ssize_t H5File::getObjCount(unsigned types) const
 //--------------------------------------------------------------------------
 void H5File::getObjIDs(unsigned types, size_t max_objs, hid_t *oid_list) const
 {
-   ssize_t ret_value = H5Fget_obj_ids(id, types, max_objs, oid_list);
-   if( ret_value < 0 )
-   {
-      throw FileIException("H5File::getObjIDs", "H5Fget_obj_ids failed");
-   }
+    ssize_t ret_value = H5Fget_obj_ids(id, types, max_objs, oid_list);
+    if(ret_value < 0)
+    {
+        throw FileIException("H5File::getObjIDs", "H5Fget_obj_ids failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -457,12 +457,12 @@ void H5File::getObjIDs(unsigned types, size_t max_objs, hid_t *oid_list) const
 //--------------------------------------------------------------------------
 void H5File::getVFDHandle(const FileAccPropList& fapl, void **file_handle) const
 {
-   hid_t fapl_id = fapl.getId();
-   herr_t ret_value = H5Fget_vfd_handle(id, fapl_id, file_handle);
-   if( ret_value < 0 )
-   {
-      throw FileIException("H5File::getVFDHandle", "H5Fget_vfd_handle failed");
-   }
+    hid_t fapl_id = fapl.getId();
+    herr_t ret_value = H5Fget_vfd_handle(id, fapl_id, file_handle);
+    if(ret_value < 0)
+    {
+        throw FileIException("H5File::getVFDHandle", "H5Fget_vfd_handle failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -497,11 +497,11 @@ void H5File::getVFDHandle(const FileAccPropList& fapl, void **file_handle) const
 //--------------------------------------------------------------------------
 void H5File::getVFDHandle(void **file_handle) const
 {
-   herr_t ret_value = H5Fget_vfd_handle(id, H5P_DEFAULT, file_handle);
-   if( ret_value < 0 )
-   {
-      throw FileIException("H5File::getVFDHandle", "H5Fget_vfd_handle failed");
-   }
+    herr_t ret_value = H5Fget_vfd_handle(id, H5P_DEFAULT, file_handle);
+    if(ret_value < 0)
+    {
+        throw FileIException("H5File::getVFDHandle", "H5Fget_vfd_handle failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -516,13 +516,13 @@ void H5File::getVFDHandle(void **file_handle) const
 //--------------------------------------------------------------------------
 hsize_t H5File::getFileSize() const
 {
-   hsize_t file_size;
-   herr_t ret_value = H5Fget_filesize(id, &file_size);
-   if (ret_value < 0)
-   {
-      throw FileIException("H5File::getFileSize", "H5Fget_filesize failed");
-   }
-   return (file_size);
+    hsize_t file_size;
+    herr_t ret_value = H5Fget_filesize(id, &file_size);
+    if (ret_value < 0)
+    {
+        throw FileIException("H5File::getFileSize", "H5Fget_filesize failed");
+    }
+    return (file_size);
 }
 
 //--------------------------------------------------------------------------
@@ -539,7 +539,7 @@ hsize_t H5File::getFileSize() const
 //--------------------------------------------------------------------------
 hid_t H5File::getId() const
 {
-   return(id);
+    return(id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -553,7 +553,7 @@ hid_t H5File::getId() const
 //--------------------------------------------------------------------------
 void H5File::reopen()
 {
-   H5File::reOpen();
+    H5File::reOpen();
 }
 
 //--------------------------------------------------------------------------
@@ -566,7 +566,7 @@ void H5File::reopen()
 //--------------------------------------------------------------------------
 hid_t H5File::getLocId() const
 {
-   return( getId() );
+    return(getId());
 }
 
 //--------------------------------------------------------------------------
@@ -590,8 +590,8 @@ void H5File::p_setId(const hid_t new_id)
     catch (Exception& E) {
         throw FileIException("H5File::p_setId", E.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -606,8 +606,8 @@ void H5File::close()
 {
     if (p_valid_id(id))
     {
-        herr_t ret_value = H5Fclose( id );
-        if( ret_value < 0 )
+        herr_t ret_value = H5Fclose(id);
+        if(ret_value < 0)
         {
             throw FileIException("H5File::close", "H5Fclose failed");
         }
@@ -632,9 +632,9 @@ void H5File::close()
 //--------------------------------------------------------------------------
 void H5File::throwException(const H5std_string& func_name, const H5std_string& msg) const
 {
-   H5std_string full_name = func_name;
-   full_name.insert(0, "H5File::");
-   throw FileIException(full_name, msg);
+    H5std_string full_name = func_name;
+    full_name.insert(0, "H5File::");
+    throw FileIException(full_name, msg);
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5File.h b/c++/src/H5File.h
index 22bb6c5..bf6e655 100644
--- a/c++/src/H5File.h
+++ b/c++/src/H5File.h
@@ -26,12 +26,12 @@ namespace H5 {
 class H5_DLLCPP H5File : public H5Location, public CommonFG {
    public:
         // Creates or opens an HDF5 file.
-        H5File( const char* name, unsigned int flags,
+        H5File(const char* name, unsigned int flags,
            const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT,
-           const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
-        H5File( const H5std_string& name, unsigned int flags,
+           const FileAccPropList& access_plist = FileAccPropList::DEFAULT);
+        H5File(const H5std_string& name, unsigned int flags,
            const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT,
-           const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
+           const FileAccPropList& access_plist = FileAccPropList::DEFAULT);
 
         // Open the file
         void openFile(const H5std_string& name, unsigned int flags,
@@ -68,8 +68,8 @@ class H5_DLLCPP H5File : public H5Location, public CommonFG {
         //void getVFDHandle(FileAccPropList& fapl, void **file_handle) const; // removed from 1.8.18 and 1.10.1
 
         // Determines if a file, specified by its name, is in HDF5 format
-        static bool isHdf5(const char* name );
-        static bool isHdf5(const H5std_string& name );
+        static bool isHdf5(const char* name);
+        static bool isHdf5(const H5std_string& name);
 
         // Reopens this file.
         void reOpen();  // added for better name
@@ -115,7 +115,7 @@ class H5_DLLCPP H5File : public H5Location, public CommonFG {
 
         // This function is private and contains common code between the
         // constructors taking a string or a char*
-        void p_get_file( const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist );
+        void p_get_file(const char* name, unsigned int flags, const FileCreatPropList& create_plist, const FileAccPropList& access_plist);
 
 }; // end of H5File
 } // namespace H5
diff --git a/c++/src/H5FloatType.cpp b/c++/src/H5FloatType.cpp
index 0e2d0c7..0e3417b 100644
--- a/c++/src/H5FloatType.cpp
+++ b/c++/src/H5FloatType.cpp
@@ -48,10 +48,10 @@ FloatType::FloatType() {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType::FloatType( const PredType& pred_type ) : AtomType()
+FloatType::FloatType(const PredType& pred_type) : AtomType()
 {
-   // use DataType::copy to make a copy of this predefined type
-   copy( pred_type );
+    // use DataType::copy to make a copy of this predefined type
+    copy(pred_type);
 }
 
 //--------------------------------------------------------------------------
@@ -62,14 +62,14 @@ FloatType::FloatType( const PredType& pred_type ) : AtomType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType::FloatType( const hid_t existing_id ) : AtomType( existing_id ) {}
+FloatType::FloatType(const hid_t existing_id) : AtomType(existing_id) {}
 
 //--------------------------------------------------------------------------
 // Function:    FloatType copy constructor
 ///\brief       Copy constructor: makes a copy of the original FloatType object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType::FloatType( const FloatType&  original ) : AtomType( original ){}
+FloatType::FloatType(const FloatType&  original) : AtomType(original){}
 
 //--------------------------------------------------------------------------
 // Function:    EnumType overloaded constructor
@@ -79,15 +79,15 @@ FloatType::FloatType( const FloatType&  original ) : AtomType( original ){}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-FloatType::FloatType( const DataSet& dataset ) : AtomType()
+FloatType::FloatType(const DataSet& dataset) : AtomType()
 {
-   // Calls C function H5Dget_type to get the id of the datatype
-   id = H5Dget_type( dataset.getId() );
+    // Calls C function H5Dget_type to get the id of the datatype
+    id = H5Dget_type(dataset.getId());
 
-   if( id < 0 )
-   {
-      throw DataSetIException("FloatType constructor", "H5Dget_type failed");
-   }
+    if(id < 0)
+    {
+        throw DataSetIException("FloatType constructor", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -101,13 +101,13 @@ FloatType::FloatType( const DataSet& dataset ) : AtomType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FloatType::getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mpos, size_t& msize ) const
+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("FloatType::getFields", "H5Tget_fields failed");
-   }
+    herr_t ret_value = H5Tget_fields(id, &spos, &epos, &esize, &mpos, &msize);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("FloatType::getFields", "H5Tget_fields failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -122,13 +122,13 @@ void FloatType::getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mp
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FloatType::setFields( size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize ) const
+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("FloatType::setFields", "H5Tset_fields failed");
-   }
+    herr_t ret_value = H5Tset_fields(id, spos, epos, esize, mpos, msize);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("FloatType::setFields", "H5Tset_fields failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -140,13 +140,13 @@ void FloatType::setFields( size_t spos, size_t epos, size_t esize, size_t mpos,
 //--------------------------------------------------------------------------
 size_t FloatType::getEbias() const
 {
-   size_t ebias = H5Tget_ebias( id );
-   // Returns the bias if successful
-   if( ebias == 0 )
-   {
-      throw DataTypeIException("FloatType::getEbias", "H5Tget_ebias failed - returned exponent bias as 0");
-   }
-   return( ebias );
+    size_t ebias = H5Tget_ebias(id);
+    // Returns the bias if successful
+    if(ebias == 0)
+    {
+        throw DataTypeIException("FloatType::getEbias", "H5Tget_ebias failed - returned exponent bias as 0");
+    }
+    return(ebias);
 }
 
 //--------------------------------------------------------------------------
@@ -156,13 +156,13 @@ size_t FloatType::getEbias() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FloatType::setEbias( size_t ebias ) const
+void FloatType::setEbias(size_t ebias) const
 {
-   herr_t ret_value = H5Tset_ebias( id, ebias );
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("FloatType::setEbias", "H5Tset_ebias failed");
-   }
+    herr_t ret_value = H5Tset_ebias(id, ebias);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("FloatType::setEbias", "H5Tset_ebias failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -180,21 +180,21 @@ void FloatType::setEbias( size_t ebias ) const
 ///             \a norm_string.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5T_norm_t FloatType::getNorm( H5std_string& norm_string ) const
+H5T_norm_t FloatType::getNorm(H5std_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("FloatType::getNorm", "H5Tget_norm failed - returned H5T_NORM_ERROR");
-   }
-   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 );
+    H5T_norm_t norm = H5Tget_norm(id);  // C routine
+    // Returns a valid normalization type if successful
+    if(norm == H5T_NORM_ERROR)
+    {
+        throw DataTypeIException("FloatType::getNorm", "H5Tget_norm failed - returned H5T_NORM_ERROR");
+    }
+    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);
 }
 
 //--------------------------------------------------------------------------
@@ -209,13 +209,13 @@ H5T_norm_t FloatType::getNorm( H5std_string& norm_string ) const
 ///             \li \c H5T_NORM_NONE (2) - Mantissa is not normalized
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FloatType::setNorm( H5T_norm_t norm ) const
+void FloatType::setNorm(H5T_norm_t norm) const
 {
-   herr_t ret_value = H5Tset_norm( id, norm );
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("FloatType::setNorm", "H5Tset_norm failed");
-   }
+    herr_t ret_value = H5Tset_norm(id, norm);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("FloatType::setNorm", "H5Tset_norm failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -233,21 +233,21 @@ void FloatType::setNorm( H5T_norm_t norm ) const
 ///             \a pad_string.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5T_pad_t FloatType::getInpad( H5std_string& pad_string ) const
+H5T_pad_t FloatType::getInpad(H5std_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("FloatType::getInpad", "H5Tget_inpad failed - returned H5T_PAD_ERROR");
-   }
-   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 );
+    H5T_pad_t pad_type = H5Tget_inpad(id);
+    // Returns a valid padding type if successful
+    if(pad_type == H5T_PAD_ERROR)
+    {
+        throw DataTypeIException("FloatType::getInpad", "H5Tget_inpad failed - returned H5T_PAD_ERROR");
+    }
+    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);
 }
 
 //--------------------------------------------------------------------------
@@ -267,13 +267,13 @@ H5T_pad_t FloatType::getInpad( H5std_string& pad_string ) const
 ///             \li \c H5T_PAD_BACKGROUND (2) - Leave background alone
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void FloatType::setInpad( H5T_pad_t inpad ) const
+void FloatType::setInpad(H5T_pad_t inpad) const
 {
-   herr_t ret_value = H5Tset_inpad( id, inpad );
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("FloatType::setInpad", "H5Tset_inpad failed");
-   }
+    herr_t ret_value = H5Tset_inpad(id, inpad);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("FloatType::setInpad", "H5Tset_inpad failed");
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5FloatType.h b/c++/src/H5FloatType.h
index a784105..67eee66 100644
--- a/c++/src/H5FloatType.h
+++ b/c++/src/H5FloatType.h
@@ -27,34 +27,34 @@ namespace H5 {
 class H5_DLLCPP FloatType : public AtomType {
    public:
         // Creates a floating-point type using a predefined type.
-        FloatType( const PredType& pred_type );
+        FloatType(const PredType& pred_type);
 
         // Gets the floating-point datatype of the specified dataset.
-        FloatType( const DataSet& dataset );
+        FloatType(const DataSet& dataset);
 
         // 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;
+        void setEbias(size_t ebias) const;
 
         // 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;
+        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;
+        void setFields(size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize) const;
 
         // Retrieves the internal padding type for unused bits in floating-point datatypes.
-        H5T_pad_t getInpad( H5std_string& pad_string ) const;
+        H5T_pad_t getInpad(H5std_string& pad_string) const;
 
         // Fills unused internal floating point bits.
-        void setInpad( H5T_pad_t inpad ) const;
+        void setInpad(H5T_pad_t inpad) const;
 
         // Retrieves mantissa normalization of a floating-point datatype.
-        H5T_norm_t getNorm( H5std_string& norm_string ) const;
+        H5T_norm_t getNorm(H5std_string& norm_string) const;
 
         // Sets the mantissa normalization of a floating-point datatype.
-        void setNorm( H5T_norm_t norm ) const;
+        void setNorm(H5T_norm_t norm) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("FloatType"); }
@@ -63,10 +63,10 @@ class H5_DLLCPP FloatType : public AtomType {
         FloatType();
 
         // Creates a floating-point datatype using an existing id.
-        FloatType( const hid_t existing_id );
+        FloatType(const hid_t existing_id);
 
         // Copy constructor: makes a copy of the original FloatType object.
-        FloatType( const FloatType& original );
+        FloatType(const FloatType& original);
 
         // Noop destructor.
         virtual ~FloatType();
diff --git a/c++/src/H5Group.cpp b/c++/src/H5Group.cpp
index 9e131ca..1bcafe1 100644
--- a/c++/src/H5Group.cpp
+++ b/c++/src/H5Group.cpp
@@ -71,7 +71,7 @@ Group::Group(const Group& original) : H5Object(), CommonFG(), id(original.id)
 //--------------------------------------------------------------------------
 hid_t Group::getLocId() const
 {
-   return( getId() );
+    return(getId());
 }
 
 //--------------------------------------------------------------------------
@@ -130,7 +130,7 @@ Group::Group(const Attribute& attr, const void* ref, H5R_type_t ref_type) : H5Ob
 //--------------------------------------------------------------------------
 hid_t Group::getId() const
 {
-   return(id);
+    return(id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -155,8 +155,8 @@ void Group::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw GroupIException("Group::p_setId", close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -171,8 +171,8 @@ void Group::close()
 {
     if (p_valid_id(id))
     {
-        herr_t ret_value = H5Gclose( id );
-        if( ret_value < 0 )
+        herr_t ret_value = H5Gclose(id);
+        if(ret_value < 0)
         {
             throw GroupIException("Group::close", "H5Gclose failed");
         }
@@ -197,9 +197,9 @@ void Group::close()
 //--------------------------------------------------------------------------
 void Group::throwException(const H5std_string& func_name, const H5std_string& msg) const
 {
-   H5std_string full_name = func_name;
-   full_name.insert(0, "Group::");
-   throw GroupIException(full_name, msg);
+    H5std_string full_name = func_name;
+    full_name.insert(0, "Group::");
+    throw GroupIException(full_name, msg);
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5Group.h b/c++/src/H5Group.h
index 9f789f1..244f99e 100644
--- a/c++/src/H5Group.h
+++ b/c++/src/H5Group.h
@@ -54,7 +54,7 @@ class H5_DLLCPP Group : public H5Object, public CommonFG {
         virtual ~Group();
 
         // Creates a copy of an existing group using its id.
-        Group( const hid_t group_id );
+        Group(const hid_t group_id);
 
    protected:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/c++/src/H5IdComponent.cpp b/c++/src/H5IdComponent.cpp
index 67b2e11..7b36d64 100644
--- a/c++/src/H5IdComponent.cpp
+++ b/c++/src/H5IdComponent.cpp
@@ -181,7 +181,7 @@ H5I_type_t IdComponent::getHDFObjType() const
 //              care of close() and setId takes care incRefCount().
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IdComponent& IdComponent::operator=( const IdComponent& rhs )
+IdComponent& IdComponent::operator=(const IdComponent& rhs)
 {
     if (this != &rhs)
     {
@@ -221,11 +221,11 @@ IdComponent& IdComponent::operator=( const IdComponent& rhs )
 //--------------------------------------------------------------------------
 void IdComponent::setId(const hid_t new_id)
 {
-   // set to new_id
-   p_setId(new_id);
+    // set to new_id
+    p_setId(new_id);
 
-   // increment the reference counter of the new id
-   incRefCount();
+    // increment the reference counter of the new id
+    incRefCount();
 }
 
 //--------------------------------------------------------------------------
@@ -255,10 +255,10 @@ IdComponent::~IdComponent() {}
 //--------------------------------------------------------------------------
 H5std_string IdComponent::inMemFunc(const char* func_name) const
 {
-   H5std_string full_name = func_name;
-   full_name.insert(0, "::");
-   full_name.insert(0, fromClass());
-   return (full_name);
+    H5std_string full_name = func_name;
+    full_name.insert(0, "::");
+    full_name.insert(0, fromClass());
+    return (full_name);
 }
 
 //--------------------------------------------------------------------------
@@ -289,34 +289,34 @@ IdComponent::IdComponent()
 //--------------------------------------------------------------------------
 H5std_string IdComponent::p_get_file_name() const
 {
-   hid_t temp_id = getId();
+    hid_t temp_id = getId();
 
-   // Preliminary call to H5Fget_name to get the length of the file name
-   ssize_t name_size = H5Fget_name(temp_id, NULL, 0);
+    // Preliminary call to H5Fget_name to get the length of the file name
+    ssize_t name_size = H5Fget_name(temp_id, NULL, 0);
 
-   // If H5Aget_name returns a negative value, raise an exception,
-   if( name_size < 0 )
-   {
-      throw IdComponentException("", "H5Fget_name failed");
-   }
+    // If H5Aget_name returns a negative value, raise an exception,
+    if(name_size < 0)
+    {
+        throw IdComponentException("", "H5Fget_name failed");
+    }
 
-   // Call H5Fget_name again to get the actual file name
-   char* name_C = new char[name_size+1];  // temporary C-string for C API
-   HDmemset(name_C, 0, name_size+1); // clear buffer
+    // Call H5Fget_name again to get the actual file name
+    char* name_C = new char[name_size+1];  // temporary C-string for C API
+    HDmemset(name_C, 0, name_size+1); // clear buffer
 
-   name_size = H5Fget_name(temp_id, name_C, name_size+1);
+    name_size = H5Fget_name(temp_id, name_C, name_size+1);
 
-   // Check for failure again
-   if( name_size < 0 )
-   {
+    // Check for failure again
+    if(name_size < 0)
+    {
       delete []name_C;
-      throw IdComponentException("", "H5Fget_name failed");
-   }
+        throw IdComponentException("", "H5Fget_name failed");
+    }
 
-   // Convert the C file name and return
-   H5std_string file_name(name_C);
-   delete []name_C;
-   return(file_name);
+    // Convert the C file name and return
+    H5std_string file_name(name_C);
+    delete []name_C;
+    return(file_name);
 }
 
 //
diff --git a/c++/src/H5IdComponent.h b/c++/src/H5IdComponent.h
index 7874af5..24d1d1b 100644
--- a/c++/src/H5IdComponent.h
+++ b/c++/src/H5IdComponent.h
@@ -49,7 +49,7 @@ class H5_DLLCPP IdComponent {
         H5I_type_t getHDFObjType() const;
 
         // Assignment operator.
-        IdComponent& operator=( const IdComponent& rhs );
+        IdComponent& operator=(const IdComponent& rhs);
 
         // Sets the identifier of this object to a new value.
         void setId(const hid_t new_id);
@@ -62,12 +62,12 @@ class H5_DLLCPP IdComponent {
         // removal does not raise any problems in two 1.10 releases.
 
         // Creates an object to hold an HDF5 identifier.
-        IdComponent( const hid_t h5_id );
+        IdComponent(const hid_t h5_id);
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
         // Copy constructor: makes copy of the original IdComponent object.
-        // IdComponent( const IdComponent& original ); - removed from 1.8.15
+        // IdComponent(const IdComponent& original); - removed from 1.8.15
 
         // Gets the identifier of this object.
         virtual hid_t getId () const = 0;
diff --git a/c++/src/H5IntType.cpp b/c++/src/H5IntType.cpp
index 446bcc6..cd87306 100644
--- a/c++/src/H5IntType.cpp
+++ b/c++/src/H5IntType.cpp
@@ -47,7 +47,7 @@ IntType::IntType() {}
 ///\brief       Copy constructor: makes a copy of the original IntType object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType::IntType( const IntType& original ) : AtomType( original ) {}
+IntType::IntType(const IntType& original) : AtomType(original) {}
 
 //--------------------------------------------------------------------------
 // Function:    IntType overloaded constructor
@@ -56,10 +56,10 @@ IntType::IntType( const IntType& original ) : AtomType( original ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType::IntType( const PredType& pred_type ) : AtomType()
+IntType::IntType(const PredType& pred_type) : AtomType()
 {
-   // use DataType::copy to make a copy of this predefined type
-   copy( pred_type );
+    // use DataType::copy to make a copy of this predefined type
+    copy(pred_type);
 }
 
 //--------------------------------------------------------------------------
@@ -70,7 +70,7 @@ IntType::IntType( const PredType& pred_type ) : AtomType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType::IntType( const hid_t existing_id ) : AtomType( existing_id ) {}
+IntType::IntType(const hid_t existing_id) : AtomType(existing_id) {}
 
 //--------------------------------------------------------------------------
 // Function:    IntType overloaded constructor
@@ -79,15 +79,15 @@ IntType::IntType( const hid_t existing_id ) : AtomType( existing_id ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-IntType::IntType( const DataSet& dataset ) : AtomType()
+IntType::IntType(const DataSet& dataset) : AtomType()
 {
-   // Calls C function H5Dget_type to get the id of the datatype
-   id = H5Dget_type( dataset.getId() );
+    // Calls C function H5Dget_type to get the id of the datatype
+    id = H5Dget_type(dataset.getId());
 
-   if( id < 0 )
-   {
-      throw DataSetIException("IntType constructor", "H5Dget_type failed");
-   }
+    if(id < 0)
+    {
+        throw DataSetIException("IntType constructor", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -99,15 +99,15 @@ IntType::IntType( const DataSet& dataset ) : AtomType()
 //--------------------------------------------------------------------------
 H5T_sign_t IntType::getSign() const
 {
-   H5T_sign_t type_sign = H5Tget_sign( id );  // C routine
+    H5T_sign_t type_sign = H5Tget_sign(id);  // C routine
 
-   // Returns a valid sign type if no errors
-   if( type_sign == H5T_SGN_ERROR )
-   {
-      throw DataTypeIException("IntType::getSign",
+    // Returns a valid sign type if no errors
+    if(type_sign == H5T_SGN_ERROR)
+    {
+        throw DataTypeIException("IntType::getSign",
                 "H5Tget_sign failed - returned H5T_SGN_ERROR for the sign type");
-   }
-   return( type_sign );
+    }
+    return(type_sign);
 }
 
 //--------------------------------------------------------------------------
@@ -117,14 +117,14 @@ H5T_sign_t IntType::getSign() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void IntType::setSign( H5T_sign_t sign ) const
+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("IntType::setSign", "H5Tset_sign failed");
-   }
+    // Call C routine to set the sign property
+    herr_t ret_value = H5Tset_sign(id, sign);
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("IntType::setSign", "H5Tset_sign failed");
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5IntType.h b/c++/src/H5IntType.h
index 355a51b..628df12 100644
--- a/c++/src/H5IntType.h
+++ b/c++/src/H5IntType.h
@@ -36,7 +36,7 @@ class H5_DLLCPP IntType : public AtomType {
         H5T_sign_t getSign() const;
 
         // Sets the sign proprety for an integer type.
-        void setSign( H5T_sign_t sign ) const;
+        void setSign(H5T_sign_t sign) const;
 
         ///\brief Returns this class name.
         virtual H5std_string fromClass () const { return("IntType"); }
diff --git a/c++/src/H5Library.cpp b/c++/src/H5Library.cpp
index a2858a4..62e21b8 100644
--- a/c++/src/H5Library.cpp
+++ b/c++/src/H5Library.cpp
@@ -44,11 +44,11 @@ namespace H5 {
 //--------------------------------------------------------------------------
 void H5Library::open()
 {
-   herr_t ret_value = H5open();
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::open", "H5open failed");
-   }
+    herr_t ret_value = H5open();
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::open", "H5open failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -60,11 +60,11 @@ void H5Library::open()
 //--------------------------------------------------------------------------
 void H5Library::close()
 {
-   herr_t ret_value = H5close();
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::close", "H5close failed");
-   }
+    herr_t ret_value = H5close();
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::close", "H5close failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -79,7 +79,7 @@ void H5Library::close()
 //--------------------------------------------------------------------------
 void H5Library::dontAtExit()
 {
-   herr_t ret_value = H5dont_atexit();
+    herr_t ret_value = H5dont_atexit();
 }
 
 //--------------------------------------------------------------------------
@@ -91,13 +91,13 @@ void H5Library::dontAtExit()
 ///\exception   H5::LibraryIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void H5Library::getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum )
+void H5Library::getLibVersion(unsigned& majnum, unsigned& minnum, unsigned& relnum)
 {
-   herr_t ret_value = H5get_libversion( &majnum, &minnum, &relnum );
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::getLibVersion", "H5get_libversion failed");
-   }
+    herr_t ret_value = H5get_libversion(&majnum, &minnum, &relnum);
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::getLibVersion", "H5get_libversion failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -116,11 +116,11 @@ void H5Library::getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& rel
 //--------------------------------------------------------------------------
 void H5Library::checkVersion(unsigned majnum, unsigned minnum, unsigned relnum)
 {
-   herr_t ret_value = H5check_version(majnum, minnum, relnum);
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::checkVersion", "H5check_version failed");
-   }
+    herr_t ret_value = H5check_version(majnum, minnum, relnum);
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::checkVersion", "H5check_version failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -145,11 +145,11 @@ void H5Library::checkVersion(unsigned majnum, unsigned minnum, unsigned relnum)
 //--------------------------------------------------------------------------
 void H5Library::garbageCollect()
 {
-   herr_t ret_value = H5garbage_collect();
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::garbageCollect", "H5garbage_collect failed");
-   }
+    herr_t ret_value = H5garbage_collect();
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::garbageCollect", "H5garbage_collect failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -184,23 +184,23 @@ void H5Library::initH5cpp()
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating PropList::deleteConstants failed");
 
-     ret_value = std::atexit(FileAccPropList::deleteConstants);
+    ret_value = std::atexit(FileAccPropList::deleteConstants);
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating FileAccPropList::deleteConstants failed");
 
-     ret_value = std::atexit(FileCreatPropList::deleteConstants);
+    ret_value = std::atexit(FileCreatPropList::deleteConstants);
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating FileCreatPropList::deleteConstants failed");
 
-     ret_value = std::atexit(DSetMemXferPropList::deleteConstants);
+    ret_value = std::atexit(DSetMemXferPropList::deleteConstants);
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating DSetMemXferPropList::deleteConstants failed");
 
-     ret_value = std::atexit(DSetCreatPropList::deleteConstants);
+    ret_value = std::atexit(DSetCreatPropList::deleteConstants);
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating DSetCreatPropList::deleteConstants failed");
 
-     ret_value = std::atexit(ObjCreatPropList::deleteConstants);
+    ret_value = std::atexit(ObjCreatPropList::deleteConstants);
     if (ret_value != 0)
         throw LibraryIException("H5Library::initH5cpp", "Registrating ObjCreatPropList::deleteConstants failed");
 
@@ -245,11 +245,11 @@ void H5Library::setFreeListLimits(int reg_global_lim, int reg_list_lim,
         int arr_global_lim, int arr_list_lim, int blk_global_lim,
         int blk_list_lim)
 {
-   herr_t ret_value = H5set_free_list_limits(reg_global_lim, reg_list_lim, arr_global_lim, arr_list_lim, blk_global_lim, blk_list_lim);
-   if( ret_value < 0 )
-   {
-      throw LibraryIException("H5Library::setFreeListLimits", "H5set_free_list_limits failed");
-   }
+    herr_t ret_value = H5set_free_list_limits(reg_global_lim, reg_list_lim, arr_global_lim, arr_list_lim, blk_global_lim, blk_list_lim);
+    if(ret_value < 0)
+    {
+        throw LibraryIException("H5Library::setFreeListLimits", "H5set_free_list_limits failed");
+    }
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/c++/src/H5Library.h b/c++/src/H5Library.h
index a93a68b..ff0cd20 100644
--- a/c++/src/H5Library.h
+++ b/c++/src/H5Library.h
@@ -36,11 +36,11 @@ class H5_DLLCPP H5Library {
         static void dontAtExit();
 
         // Returns the HDF library release number.
-        static void getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum );
+        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 );
+        static void checkVersion(unsigned majnum, unsigned minnum, unsigned relnum);
 
         // Walks through all the garbage collection routines for the library,
         // which are supposed to free any unused memory they have allocated.
diff --git a/c++/src/H5Location.cpp b/c++/src/H5Location.cpp
index 05c3e23..709a94e 100644
--- a/c++/src/H5Location.cpp
+++ b/c++/src/H5Location.cpp
@@ -44,14 +44,14 @@ namespace H5 {
 extern "C" herr_t userAttrOpWrpr(hid_t loc_id, const char *attr_name,
     const H5A_info_t *ainfo, void *op_data)
 {
-   H5std_string s_attr_name = H5std_string( attr_name );
+    H5std_string s_attr_name = H5std_string(attr_name);
 #ifdef NO_STATIC_CAST
-   UserData4Aiterate* myData = (UserData4Aiterate *) op_data;
+    UserData4Aiterate* myData = (UserData4Aiterate *) op_data;
 #else
-   UserData4Aiterate* myData = static_cast <UserData4Aiterate *> (op_data);
+    UserData4Aiterate* myData = static_cast <UserData4Aiterate *> (op_data);
 #endif
-   myData->op( *myData->location, s_attr_name, myData->opData );
-   return 0;
+    myData->op(*myData->location, s_attr_name, myData->opData);
+    return 0;
 }
 
 //--------------------------------------------------------------------------
@@ -113,22 +113,22 @@ H5Location::H5Location() : IdComponent() {}
 ///             recreate it with this function.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Attribute H5Location::createAttribute( const char* name, const DataType& data_type, const DataSpace& data_space, const PropList& create_plist ) const
+Attribute H5Location::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 = H5Acreate2(getId(), name, type_id, space_id, plist_id, H5P_DEFAULT );
+    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 = H5Acreate2(getId(), name, type_id, space_id, plist_id, H5P_DEFAULT);
 
-   // If the attribute id is valid, create and return the Attribute object
-   if( attr_id > 0 )
-   {
+    // If the attribute id is valid, create and return the Attribute object
+    if(attr_id > 0)
+    {
         Attribute attr;
         f_Attribute_setId(&attr, attr_id);
-        return( attr );
-   }
-   else
-      throw AttributeIException(inMemFunc("createAttribute"), "H5Acreate2 failed");
+        return(attr);
+    }
+    else
+        throw AttributeIException(inMemFunc("createAttribute"), "H5Acreate2 failed");
 }
 
 //--------------------------------------------------------------------------
@@ -138,9 +138,9 @@ Attribute H5Location::createAttribute( const char* name, const DataType& data_ty
 ///             a reference to an \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Attribute H5Location::createAttribute( const H5std_string& name, const DataType& data_type, const DataSpace& data_space, const PropList& create_plist ) const
+Attribute H5Location::createAttribute(const H5std_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 ));
+    return(createAttribute(name.c_str(), data_type, data_space, create_plist));
 }
 
 //--------------------------------------------------------------------------
@@ -151,19 +151,19 @@ Attribute H5Location::createAttribute( const H5std_string& name, const DataType&
 ///\exception   H5::AttributeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Attribute H5Location::openAttribute( const char* name ) const
+Attribute H5Location::openAttribute(const char* name) const
 {
-   hid_t attr_id = H5Aopen(getId(), name, H5P_DEFAULT);
-   if( attr_id > 0 )
-   {
+    hid_t attr_id = H5Aopen(getId(), name, H5P_DEFAULT);
+    if(attr_id > 0)
+    {
         Attribute attr;
         f_Attribute_setId(&attr, attr_id);
-        return( attr );
-   }
-   else
-   {
-      throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen failed");
-   }
+        return(attr);
+    }
+    else
+    {
+        throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -173,9 +173,9 @@ Attribute H5Location::openAttribute( const char* name ) const
 ///             a reference to an \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Attribute H5Location::openAttribute( const H5std_string& name ) const
+Attribute H5Location::openAttribute(const H5std_string& name) const
 {
-   return( openAttribute( name.c_str()) );
+    return(openAttribute(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -186,20 +186,20 @@ Attribute H5Location::openAttribute( const H5std_string& name ) const
 ///\exception   H5::AttributeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-Attribute H5Location::openAttribute( const unsigned int idx ) const
+Attribute H5Location::openAttribute(const unsigned int idx) const
 {
-   hid_t attr_id = H5Aopen_by_idx(getId(), ".", H5_INDEX_CRT_ORDER,
+    hid_t attr_id = H5Aopen_by_idx(getId(), ".", H5_INDEX_CRT_ORDER,
                 H5_ITER_INC, static_cast<hsize_t>(idx), H5P_DEFAULT, H5P_DEFAULT);
-   if( attr_id > 0 )
-   {
+    if(attr_id > 0)
+    {
         Attribute attr;
         f_Attribute_setId(&attr, attr_id);
         return(attr);
-   }
-   else
-   {
+    }
+    else
+    {
         throw AttributeIException(inMemFunc("openAttribute"), "H5Aopen_by_idx failed");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -220,31 +220,31 @@ Attribute H5Location::openAttribute( const unsigned int idx ) const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5A.html#Annot-Iterate
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int H5Location::iterateAttrs( attr_operator_t user_op, unsigned *_idx, void *op_data )
+int H5Location::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->op = user_op;
-   userData->location = this;
+    // store the user's function and data
+    UserData4Aiterate* userData = new UserData4Aiterate;
+    userData->opData = op_data;
+    userData->op = user_op;
+    userData->location = this;
 
-   // call the C library routine H5Aiterate2 to iterate the attributes
-   hsize_t idx = _idx ? static_cast<hsize_t>(*_idx) : 0;
-   int ret_value = H5Aiterate2(getId(), H5_INDEX_NAME, H5_ITER_INC, &idx,
+    // call the C library routine H5Aiterate2 to iterate the attributes
+    hsize_t idx = _idx ? static_cast<hsize_t>(*_idx) : 0;
+    int ret_value = H5Aiterate2(getId(), H5_INDEX_NAME, H5_ITER_INC, &idx,
                         userAttrOpWrpr, static_cast<void *>(userData));
 
-   // release memory
-   delete userData;
+    // release memory
+    delete userData;
 
-   if( ret_value >= 0 ) {
-      /* Pass back update index value to calling code */
-      if (_idx)
-         *_idx = static_cast<unsigned>(idx);
+    if(ret_value >= 0) {
+        /* Pass back update index value to calling code */
+        if (_idx)
+            *_idx = static_cast<unsigned>(idx);
 
-      return( ret_value );
-   }
-   else  // raise exception when H5Aiterate returns a negative value
-      throw AttributeIException(inMemFunc("iterateAttrs"), "H5Aiterate2 failed");
+        return(ret_value);
+    }
+    else  // raise exception when H5Aiterate returns a negative value
+        throw AttributeIException(inMemFunc("iterateAttrs"), "H5Aiterate2 failed");
 }
 
 //--------------------------------------------------------------------------
@@ -258,10 +258,10 @@ int H5Location::getNumAttrs() const
 {
    H5O_info_t oinfo;    /* Object info */
 
-   if(H5Oget_info(getId(), &oinfo) < 0)
-      throw AttributeIException(inMemFunc("getNumAttrs"), "H5Oget_info failed");
-   else
-      return(static_cast<int>(oinfo.num_attrs));
+    if(H5Oget_info(getId(), &oinfo) < 0)
+        throw AttributeIException(inMemFunc("getNumAttrs"), "H5Oget_info failed");
+    else
+        return(static_cast<int>(oinfo.num_attrs));
 }
 
 //--------------------------------------------------------------------------
@@ -273,16 +273,16 @@ int H5Location::getNumAttrs() const
 //--------------------------------------------------------------------------
 bool H5Location::attrExists(const char* name) const
 {
-   // Call C routine H5Aexists to determine whether an attribute exists
-   // at this location, which could be specified by a file, group, dataset,
-   // or named datatype.
-   herr_t ret_value = H5Aexists(getId(), name);
-   if( ret_value > 0 )
-      return true;
-   else if(ret_value == 0)
-      return false;
-   else // Raise exception when H5Aexists returns a negative value
-      throw AttributeIException(inMemFunc("attrExists"), "H5Aexists failed");
+    // Call C routine H5Aexists to determine whether an attribute exists
+    // at this location, which could be specified by a file, group, dataset,
+    // or named datatype.
+    herr_t ret_value = H5Aexists(getId(), name);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else // Raise exception when H5Aexists returns a negative value
+        throw AttributeIException(inMemFunc("attrExists"), "H5Aexists failed");
 }
 
 //--------------------------------------------------------------------------
@@ -294,7 +294,7 @@ bool H5Location::attrExists(const char* name) const
 //--------------------------------------------------------------------------
 bool H5Location::attrExists(const H5std_string& name) const
 {
-   return(attrExists(name.c_str()));
+    return(attrExists(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -304,11 +304,11 @@ bool H5Location::attrExists(const H5std_string& name) const
 ///\exception   H5::AttributeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void H5Location::removeAttr( const char* name ) const
+void H5Location::removeAttr(const char* name) const
 {
-   herr_t ret_value = H5Adelete(getId(), name);
-   if( ret_value < 0 )
-      throw AttributeIException(inMemFunc("removeAttr"), "H5Adelete failed");
+    herr_t ret_value = H5Adelete(getId(), name);
+    if(ret_value < 0)
+        throw AttributeIException(inMemFunc("removeAttr"), "H5Adelete failed");
 }
 
 //--------------------------------------------------------------------------
@@ -318,9 +318,9 @@ void H5Location::removeAttr( const char* name ) const
 ///             a reference to an \c H5std_string for \a name.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void H5Location::removeAttr( const H5std_string& name ) const
+void H5Location::removeAttr(const H5std_string& name) const
 {
-   removeAttr( name.c_str() );
+    removeAttr(name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -333,9 +333,9 @@ void H5Location::removeAttr( const H5std_string& name ) const
 //--------------------------------------------------------------------------
 void H5Location::renameAttr(const char* oldname, const char* newname) const
 {
-   herr_t ret_value = H5Arename(getId(), oldname, newname);
-   if (ret_value < 0)
-      throw AttributeIException(inMemFunc("renameAttr"), "H5Arename failed");
+    herr_t ret_value = H5Arename(getId(), oldname, newname);
+    if (ret_value < 0)
+        throw AttributeIException(inMemFunc("renameAttr"), "H5Arename failed");
 }
 
 //--------------------------------------------------------------------------
@@ -367,11 +367,11 @@ void H5Location::renameAttr(const H5std_string& oldname, const H5std_string& new
 //--------------------------------------------------------------------------
 void H5Location::flush(H5F_scope_t scope) const
 {
-   herr_t ret_value = H5Fflush(getId(), scope);
-   if( ret_value < 0 )
-   {
-      throw LocationException(inMemFunc("flush"), "H5Fflush failed");
-   }
+    herr_t ret_value = H5Fflush(getId(), scope);
+    if(ret_value < 0)
+    {
+        throw LocationException(inMemFunc("flush"), "H5Fflush failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -383,12 +383,12 @@ void H5Location::flush(H5F_scope_t scope) const
 //--------------------------------------------------------------------------
 H5std_string H5Location::getFileName() const
 {
-   try {
-      return(p_get_file_name());
-   }
-   catch (LocationException& E) {
-      throw FileIException(inMemFunc("getFileName"), E.getDetailMsg());
-   }
+    try {
+        return(p_get_file_name());
+    }
+    catch (LocationException& E) {
+        throw FileIException(inMemFunc("getFileName"), E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -413,9 +413,9 @@ H5std_string H5Location::getFileName() const
 //--------------------------------------------------------------------------
 void H5Location::setComment(const char* name, const char* comment) const
 {
-   herr_t ret_value = H5Oset_comment_by_name(getId(), name, comment, H5P_DEFAULT);
-   if( ret_value < 0 )
-      throw LocationException(inMemFunc("setComment"), "H5Oset_comment_by_name failed");
+    herr_t ret_value = H5Oset_comment_by_name(getId(), name, comment, H5P_DEFAULT);
+    if(ret_value < 0)
+        throw LocationException(inMemFunc("setComment"), "H5Oset_comment_by_name failed");
 }
 
 //--------------------------------------------------------------------------
@@ -427,7 +427,7 @@ void H5Location::setComment(const char* name, const char* comment) const
 //--------------------------------------------------------------------------
 void H5Location::setComment(const H5std_string& name, const H5std_string& comment) const
 {
-   setComment(name.c_str(), comment.c_str());
+    setComment(name.c_str(), comment.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -440,9 +440,9 @@ void H5Location::setComment(const H5std_string& name, const H5std_string& commen
 //--------------------------------------------------------------------------
 void H5Location::setComment(const char* comment) const
 {
-   herr_t ret_value = H5Oset_comment_by_name(getId(), ".", comment, H5P_DEFAULT);
-   if( ret_value < 0 )
-      throw LocationException(inMemFunc("setComment"), "H5Oset_comment_by_name failed");
+    herr_t ret_value = H5Oset_comment_by_name(getId(), ".", comment, H5P_DEFAULT);
+    if(ret_value < 0)
+        throw LocationException(inMemFunc("setComment"), "H5Oset_comment_by_name failed");
 }
 
 //--------------------------------------------------------------------------
@@ -454,7 +454,7 @@ void H5Location::setComment(const char* comment) const
 //--------------------------------------------------------------------------
 void H5Location::setComment(const H5std_string& comment) const
 {
-   setComment(comment.c_str());
+    setComment(comment.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -470,9 +470,9 @@ void H5Location::setComment(const H5std_string& comment) const
 //--------------------------------------------------------------------------
 void H5Location::removeComment(const char* name) const
 {
-   herr_t ret_value = H5Oset_comment_by_name(getId(), name, NULL, H5P_DEFAULT);
-   if( ret_value < 0 )
-      throw LocationException(inMemFunc("removeComment"), "H5Oset_comment_by_name failed");
+    herr_t ret_value = H5Oset_comment_by_name(getId(), name, NULL, H5P_DEFAULT);
+    if(ret_value < 0)
+        throw LocationException(inMemFunc("removeComment"), "H5Oset_comment_by_name failed");
 }
 
 //--------------------------------------------------------------------------
@@ -484,7 +484,7 @@ void H5Location::removeComment(const char* name) const
 //--------------------------------------------------------------------------
 void H5Location::removeComment(const H5std_string& name) const
 {
-   removeComment (name.c_str());
+    removeComment (name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -605,11 +605,11 @@ H5std_string H5Location::getComment(const H5std_string& name, size_t buf_size) c
 //--------------------------------------------------------------------------
 void H5Location::p_reference(void* ref, const char* name, hid_t space_id, H5R_type_t ref_type) const
 {
-   herr_t ret_value = H5Rcreate(ref, getId(), name, ref_type, space_id);
-   if (ret_value < 0)
-   {
-      throw ReferenceException(inMemFunc("reference"), "H5Rcreate failed");
-   }
+    herr_t ret_value = H5Rcreate(ref, getId(), name, ref_type, space_id);
+    if (ret_value < 0)
+    {
+        throw ReferenceException(inMemFunc("reference"), "H5Rcreate failed");
+    }
 }
 
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -630,12 +630,12 @@ void H5Location::p_reference(void* ref, const char* name, hid_t space_id, H5R_ty
 //--------------------------------------------------------------------------
 void H5Location::reference(void* ref, const char* name, const DataSpace& dataspace, H5R_type_t ref_type) const
 {
-   try {
+    try {
       p_reference(ref, name, dataspace.getId(), ref_type);
-   }
-   catch (ReferenceException& E) {
-      throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
-   }
+    }
+    catch (ReferenceException& E) {
+        throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -656,12 +656,12 @@ void H5Location::reference(void* ref, const char* name, const DataSpace& dataspa
 //--------------------------------------------------------------------------
 void H5Location::reference(void* ref, const H5std_string& name, const DataSpace& dataspace, H5R_type_t ref_type) const
 {
-   try {
+    try {
       p_reference(ref, name.c_str(), dataspace.getId(), ref_type);
-   }
-   catch (ReferenceException& E) {
-      throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
-   }
+    }
+    catch (ReferenceException& E) {
+        throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -680,12 +680,12 @@ void H5Location::reference(void* ref, const H5std_string& name, const DataSpace&
 //--------------------------------------------------------------------------
 void H5Location::reference(void* ref, const char* name, H5R_type_t ref_type) const
 {
-   try {
+    try {
       p_reference(ref, name, -1, ref_type);
-   }
-   catch (ReferenceException& E) {
-      throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
-   }
+    }
+    catch (ReferenceException& E) {
+        throw ReferenceException(inMemFunc("reference"), E.getDetailMsg());
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -703,7 +703,7 @@ void H5Location::reference(void* ref, const char* name, H5R_type_t ref_type) con
 //--------------------------------------------------------------------------
 void H5Location::reference(void* ref, const H5std_string& name, H5R_type_t ref_type) const
 {
-   reference(ref, name.c_str(), ref_type);
+    reference(ref, name.c_str(), ref_type);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -723,13 +723,13 @@ void H5Location::reference(void* ref, const H5std_string& name, H5R_type_t ref_t
 //--------------------------------------------------------------------------
 hid_t H5Location::p_dereference(hid_t loc_id, const void* ref, H5R_type_t ref_type, const char* from_func)
 {
-   hid_t temp_id = H5Rdereference(loc_id, ref_type, ref);
-   if (temp_id < 0)
-   {
-      throw ReferenceException(inMemFunc(from_func), "H5Rdereference failed");
-   }
+    hid_t temp_id = H5Rdereference(loc_id, ref_type, ref);
+    if (temp_id < 0)
+    {
+        throw ReferenceException(inMemFunc(from_func), "H5Rdereference failed");
+    }
 
-   return(temp_id);
+    return(temp_id);
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -747,7 +747,7 @@ hid_t H5Location::p_dereference(hid_t loc_id, const void* ref, H5R_type_t ref_ty
 //--------------------------------------------------------------------------
 void H5Location::dereference(const H5Location& loc, const void* ref, H5R_type_t ref_type)
 {
-   p_setId(p_dereference(loc.getId(), ref, ref_type, "dereference"));
+    p_setId(p_dereference(loc.getId(), ref, ref_type, "dereference"));
 }
 
 //--------------------------------------------------------------------------
@@ -764,7 +764,7 @@ void H5Location::dereference(const H5Location& loc, const void* ref, H5R_type_t
 //--------------------------------------------------------------------------
 void H5Location::dereference(const Attribute& attr, const void* ref, H5R_type_t ref_type)
 {
-   p_setId(p_dereference(attr.getId(), ref, ref_type, "dereference"));
+    p_setId(p_dereference(attr.getId(), ref, ref_type, "dereference"));
 }
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
@@ -789,12 +789,12 @@ void H5Location::dereference(const Attribute& attr, const void* ref, H5R_type_t
 //--------------------------------------------------------------------------
 H5G_obj_t H5Location::getObjType(void *ref, H5R_type_t ref_type) const
 {
-   try {
-      return(p_get_obj_type(ref, ref_type));
-   }
-   catch (ReferenceException& E) {
-      throw ReferenceException(inMemFunc("getObjType"), E.getDetailMsg());
-   }
+    try {
+        return(p_get_obj_type(ref, ref_type));
+    }
+    catch (ReferenceException& E) {
+        throw ReferenceException(inMemFunc("getObjType"), E.getDetailMsg());
+    }
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -816,13 +816,13 @@ H5G_obj_t H5Location::getObjType(void *ref, H5R_type_t ref_type) const
 //--------------------------------------------------------------------------
 H5G_obj_t H5Location::p_get_obj_type(void *ref, H5R_type_t ref_type) const
 {
-   H5G_obj_t obj_type = H5Rget_obj_type1(getId(), ref_type, ref);
+    H5G_obj_t obj_type = H5Rget_obj_type1(getId(), ref_type, ref);
 
-   if (obj_type == H5G_UNKNOWN)
-   {
-      throw ReferenceException(inMemFunc("getObjType"), "H5Rget_obj_type1 failed");
-   }
-   return(obj_type);
+    if (obj_type == H5G_UNKNOWN)
+    {
+        throw ReferenceException(inMemFunc("getObjType"), "H5Rget_obj_type1 failed");
+    }
+    return(obj_type);
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
@@ -845,12 +845,12 @@ H5G_obj_t H5Location::p_get_obj_type(void *ref, H5R_type_t ref_type) const
 //--------------------------------------------------------------------------
 H5O_type_t H5Location::getRefObjType(void *ref, H5R_type_t ref_type) const
 {
-   try {
-      return(p_get_ref_obj_type(ref, ref_type));
-   }
-   catch (ReferenceException& E) {
-      throw ReferenceException(inMemFunc("getRefObjType"), E.getDetailMsg());
-   }
+    try {
+        return(p_get_ref_obj_type(ref, ref_type));
+    }
+    catch (ReferenceException& E) {
+        throw ReferenceException(inMemFunc("getRefObjType"), E.getDetailMsg());
+    }
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -871,17 +871,17 @@ H5O_type_t H5Location::getRefObjType(void *ref, H5R_type_t ref_type) const
 //--------------------------------------------------------------------------
 H5O_type_t H5Location::p_get_ref_obj_type(void *ref, H5R_type_t ref_type) const
 {
-   H5O_type_t obj_type = H5O_TYPE_UNKNOWN;
-   herr_t ret_value = H5Rget_obj_type2(getId(), ref_type, ref, &obj_type);
-   if (ret_value < 0)
-   {
-      throw ReferenceException(inMemFunc("getRefObjType"), "H5Rget_obj_type2 failed");
-   }
-   if (obj_type == H5O_TYPE_UNKNOWN || obj_type >= H5O_TYPE_NTYPES)
-   {
-      throw ReferenceException(inMemFunc("getRefObjType"), "H5Rget_obj_type2 returned invalid type");
-   }
-   return(obj_type);
+    H5O_type_t obj_type = H5O_TYPE_UNKNOWN;
+    herr_t ret_value = H5Rget_obj_type2(getId(), ref_type, ref, &obj_type);
+    if (ret_value < 0)
+    {
+        throw ReferenceException(inMemFunc("getRefObjType"), "H5Rget_obj_type2 failed");
+    }
+    if (obj_type == H5O_TYPE_UNKNOWN || obj_type >= H5O_TYPE_NTYPES)
+    {
+        throw ReferenceException(inMemFunc("getRefObjType"), "H5Rget_obj_type2 returned invalid type");
+    }
+    return(obj_type);
 }
 
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -904,19 +904,19 @@ H5O_type_t H5Location::p_get_ref_obj_type(void *ref, H5R_type_t ref_type) const
 //--------------------------------------------------------------------------
 DataSpace H5Location::getRegion(void *ref, H5R_type_t ref_type) const
 {
-   hid_t space_id = H5Rget_region(getId(), ref_type, ref);
-   if (space_id < 0)
-   {
-      throw ReferenceException(inMemFunc("getRegion"), "H5Rget_region failed");
-   }
-   try {
+    hid_t space_id = H5Rget_region(getId(), ref_type, ref);
+    if (space_id < 0)
+    {
+        throw ReferenceException(inMemFunc("getRegion"), "H5Rget_region failed");
+    }
+    try {
         DataSpace dataspace;
         f_DataSpace_setId(&dataspace, space_id);
         return(dataspace);
-   }
-   catch (DataSpaceIException& E) {
-      throw ReferenceException(inMemFunc("getRegion"), E.getDetailMsg());
-   }
+    }
+    catch (DataSpaceIException& E) {
+        throw ReferenceException(inMemFunc("getRegion"), E.getDetailMsg());
+    }
 }
 
 
diff --git a/c++/src/H5Location.h b/c++/src/H5Location.h
index b93c71e..9861118 100644
--- a/c++/src/H5Location.h
+++ b/c++/src/H5Location.h
@@ -33,7 +33,7 @@ namespace H5 {
 class H5_DLLCPP H5Location;  // forward declaration for UserData4Aiterate
 
 // Define the operator function pointer for H5Aiterate().
-typedef void (*attr_operator_t)( H5Location& loc/*in*/,
+typedef void (*attr_operator_t)(H5Location& loc/*in*/,
                                  const H5std_string attr_name/*in*/,
                                  void *operator_data/*in,out*/);
 
@@ -57,20 +57,20 @@ class H5_DLLCPP H5Location : public IdComponent {
    public:
         // Creates an attribute for the specified object at this location
         // 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 H5std_string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
+        Attribute createAttribute(const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const;
+        Attribute createAttribute(const H5std_string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const;
 
         // Given its name, opens the attribute that belongs to an object at
         // this location.
-        Attribute openAttribute( const char* name ) const;
-        Attribute openAttribute( const H5std_string& name ) const;
+        Attribute openAttribute(const char* name) const;
+        Attribute openAttribute(const H5std_string& name) const;
 
         // Given its index, opens the attribute that belongs to an object at
         // this location.
-        Attribute openAttribute( const unsigned int idx ) const;
+        Attribute openAttribute(const unsigned int idx) const;
 
         // Flushes all buffers associated with this location to disk.
-        void flush( H5F_scope_t scope ) const;
+        void flush(H5F_scope_t scope) const;
 
         // Gets the name of the file, specified by this location.
         H5std_string getFileName() const;
diff --git a/c++/src/H5Object.h b/c++/src/H5Object.h
index 016f5a2..3fd29a4 100644
--- a/c++/src/H5Object.h
+++ b/c++/src/H5Object.h
@@ -63,7 +63,7 @@ class H5_DLLCPP H5Object : public H5Location {
         // removal does not raise any problems in two 1.10 releases.
 
         // Creates a copy of an existing object giving the object id
-        H5Object( const hid_t object_id );
+        H5Object(const hid_t object_id);
 
         // Copy constructor: makes copy of an H5Object object.
         // H5Object(const H5Object& original);
diff --git a/c++/src/H5OcreatProp.h b/c++/src/H5OcreatProp.h
index c14bb57..c4687f7 100644
--- a/c++/src/H5OcreatProp.h
+++ b/c++/src/H5OcreatProp.h
@@ -49,7 +49,7 @@ class H5_DLLCPP ObjCreatPropList : public PropList {
         virtual H5std_string fromClass () const { return("ObjCreatPropList"); }
 
         // Copy constructor: creates a copy of a ObjCreatPropList object.
-        ObjCreatPropList( const ObjCreatPropList& original );
+        ObjCreatPropList(const ObjCreatPropList& original);
 
         // Creates a copy of an existing object creation property list
         // using the property list id.
diff --git a/c++/src/H5PredType.cpp b/c++/src/H5PredType.cpp
index f4aca2e..a640d32 100644
--- a/c++/src/H5PredType.cpp
+++ b/c++/src/H5PredType.cpp
@@ -69,7 +69,7 @@ PredType::PredType(const PredType& original) : AtomType(original) {}
 //              the new id in the left hand side object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-PredType& PredType::operator=( const PredType& rhs )
+PredType& PredType::operator=(const PredType& rhs)
 {
     if (this != &rhs)
         copy(rhs);
@@ -79,19 +79,19 @@ PredType& PredType::operator=( const PredType& rhs )
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 // These dummy functions do not inherit from DataType - they'll
 // throw an DataTypeIException if invoked.
-void PredType::commit(H5Location& loc, const char* name )
+void PredType::commit(H5Location& loc, const char* name)
 {
-   throw DataTypeIException("PredType::commit", "Error: Attempted to commit a predefined datatype.  Invalid operation!" );
+    throw DataTypeIException("PredType::commit", "Error: Attempted to commit a predefined datatype.  Invalid operation!");
 }
 
-void PredType::commit(H5Location& loc, const H5std_string& name )
+void PredType::commit(H5Location& loc, const H5std_string& name)
 {
-   commit( loc, name.c_str());
+    commit(loc, name.c_str());
 }
 
 bool PredType::committed()
 {
-   throw DataTypeIException("PredType::committed", "Error: Attempting to check for commit status on a predefined datatype." );
+    throw DataTypeIException("PredType::committed", "Error: Attempting to check for commit status on a predefined datatype.");
 }
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
diff --git a/c++/src/H5PredType.h b/c++/src/H5PredType.h
index 447c2b5..1d95865 100644
--- a/c++/src/H5PredType.h
+++ b/c++/src/H5PredType.h
@@ -34,10 +34,10 @@ class H5_DLLCPP PredType : public AtomType {
 
         // Makes a copy of the predefined type and stores the new
         // id in the left hand side object.
-        PredType& operator=( const PredType& rhs );
+        PredType& operator=(const PredType& rhs);
 
         // Copy constructor - makes copy of the original object
-        PredType( const PredType& original );
+        PredType(const PredType& original);
 
         // Noop destructor
         virtual ~PredType();
@@ -45,11 +45,11 @@ class H5_DLLCPP PredType : public AtomType {
         /*! \brief This dummy function do not inherit from DataType - it will
             throw a DataTypeIException if invoked.
         */
-        void commit(H5Location& loc, const H5std_string& name );
+        void commit(H5Location& loc, const H5std_string& name);
         /*! \brief This dummy function do not inherit from DataType - it will
             throw a DataTypeIException if invoked.
         */
-        void commit(H5Location& loc, const char* name );
+        void commit(H5Location& loc, const char* name);
         /*! \brief This dummy function do not inherit from DataType - it will
             throw a DataTypeIException if invoked.
         */
@@ -245,7 +245,7 @@ class H5_DLLCPP PredType : public AtomType {
         PredType();
 
         // Creates a pre-defined type using an HDF5 pre-defined constant
-        PredType( const hid_t predtype_id );  // used by the library only
+        PredType(const hid_t predtype_id);  // used by the library only
 
    private:
         // Activates the creation of the PredType global constants
diff --git a/c++/src/H5PropList.cpp b/c++/src/H5PropList.cpp
index fd223b3..d7083f8 100644
--- a/c++/src/H5PropList.cpp
+++ b/c++/src/H5PropList.cpp
@@ -28,7 +28,7 @@
 #include "H5private.h"          // for HDfree
 
 
-namespace H5 {
+namespace H5{
 #ifndef H5_NO_STD
     using std::cerr;
     using std::endl;
@@ -119,7 +119,7 @@ PropList::PropList(const PropList& original) : IdComponent(), id(original.id)
 //              property's id to H5P_DEFAULT.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-PropList::PropList( const hid_t plist_id ) : IdComponent()
+PropList::PropList(const hid_t plist_id) : IdComponent()
 {
     if (plist_id <= 0)
         id = H5P_DEFAULT;
@@ -129,7 +129,7 @@ PropList::PropList( const hid_t plist_id ) : IdComponent()
         case H5I_GENPROP_CLS:
           // call C routine to create a new property from the given prop class
           id = H5Pcreate(plist_id);
-          if( id < 0 )
+          if(id < 0)
           {
               throw PropListIException("PropList constructor", "H5Pcreate failed");
           }
@@ -137,7 +137,7 @@ PropList::PropList( const hid_t plist_id ) : IdComponent()
         case H5I_GENPROP_LST:
           // call C routine to make a copy of the given property list
           id = H5Pcopy(plist_id);
-          if( id < 0 )
+          if(id < 0)
           {
               throw PropListIException("PropList constructor", "H5Pcopy failed");
           }
@@ -160,7 +160,7 @@ PropList::PropList( const hid_t plist_id ) : IdComponent()
 //              - Replaced decRefCount with close() to let the C library
 //              handle the reference counting - BMR, Jun 1, 2006
 //--------------------------------------------------------------------------
-void PropList::copy( const PropList& like_plist )
+void PropList::copy(const PropList& like_plist)
 {
     // If this object is representing an hdf5 object, close it before
     // copying like_plist to it
@@ -172,8 +172,8 @@ void PropList::copy( const PropList& like_plist )
     }
 
     // call C routine to copy the property list
-    id = H5Pcopy( like_plist.getId() );
-    if( id < 0 )
+    id = H5Pcopy(like_plist.getId());
+    if(id < 0)
         throw PropListIException(inMemFunc("copy"), "H5Pcopy failed");
 }
 
@@ -188,7 +188,7 @@ void PropList::copy( const PropList& like_plist )
 //              and stores the new id in the left hand side object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-PropList& PropList::operator=( const PropList& rhs )
+PropList& PropList::operator=(const PropList& rhs)
 {
     if (this != &rhs)
         copy(rhs);
@@ -205,12 +205,12 @@ PropList& PropList::operator=( const PropList& rhs )
 //--------------------------------------------------------------------------
 void PropList::copyProp(PropList& dest, const char *name) const
 {
-   hid_t dst_id = dest.getId();
-   herr_t ret_value = H5Pcopy_prop(dst_id, id, name);
-   if( ret_value < 0 )
-   {
-      throw PropListIException(inMemFunc("copyProp"), "H5Pcopy_prop failed");
-   }
+    hid_t dst_id = dest.getId();
+    herr_t ret_value = H5Pcopy_prop(dst_id, id, name);
+    if(ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("copyProp"), "H5Pcopy_prop failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -222,9 +222,9 @@ void PropList::copyProp(PropList& dest, const char *name) const
 ///\param       name - IN: Name of the property to copy - \c H5std_string
 // Programmer   Binh-Minh Ribler - Jul, 2005
 //--------------------------------------------------------------------------
-void PropList::copyProp( PropList& dest, const H5std_string& name ) const
+void PropList::copyProp(PropList& dest, const H5std_string& name) const
 {
-   copyProp( dest, name.c_str());
+   copyProp(dest, name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -237,15 +237,15 @@ void PropList::copyProp( PropList& dest, const H5std_string& name ) const
 ///\exception   H5::PropListIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void PropList::copyProp( PropList& dest, PropList& src, const char *name ) const
+void PropList::copyProp(PropList& dest, PropList& src, const char *name) const
 {
-   hid_t dst_id = dest.getId();
-   hid_t src_id = src.getId();
-   herr_t ret_value = H5Pcopy_prop(dst_id, src_id, name);
-   if( ret_value < 0 )
-   {
-      throw PropListIException(inMemFunc("copyProp"), "H5Pcopy_prop failed");
-   }
+    hid_t dst_id = dest.getId();
+    hid_t src_id = src.getId();
+    herr_t ret_value = H5Pcopy_prop(dst_id, src_id, name);
+    if(ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("copyProp"), "H5Pcopy_prop failed");
+    }
 
 }
 
@@ -259,9 +259,9 @@ void PropList::copyProp( PropList& dest, PropList& src, const char *name ) const
 ///\param       name - IN: Name of the property to copy - \c H5std_string
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void PropList::copyProp( PropList& dest, PropList& src, const H5std_string& name ) const
+void PropList::copyProp(PropList& dest, PropList& src, const H5std_string& name) const
 {
-   copyProp( dest, src, name.c_str());
+    copyProp(dest, src, name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -277,7 +277,7 @@ void PropList::copyProp( PropList& dest, PropList& src, const H5std_string& name
 //--------------------------------------------------------------------------
 hid_t PropList::getId() const
 {
-   return(id);
+    return(id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -302,8 +302,8 @@ void PropList::p_setId(const hid_t new_id)
     catch (Exception& close_error) {
         throw PropListIException(inMemFunc("p_setId"), close_error.getDetailMsg());
     }
-   // reset object's id to the given id
-   id = new_id;
+    // reset object's id to the given id
+    id = new_id;
 }
 
 #endif // DOXYGEN_SHOULD_SKIP_THIS
@@ -319,8 +319,8 @@ void PropList::close()
 {
     if (p_valid_id(id))
     {
-        herr_t ret_value = H5Pclose( id );
-        if( ret_value < 0 )
+        herr_t ret_value = H5Pclose(id);
+        if(ret_value < 0)
         {
             throw PropListIException(inMemFunc("close"), "H5Pclose failed");
         }
@@ -338,13 +338,13 @@ void PropList::close()
 //--------------------------------------------------------------------------
 hid_t PropList::getClass() const
 {
-   hid_t plist_class = H5Pget_class( id );
-   if( plist_class == H5P_ROOT )
-   {
-      throw PropListIException(inMemFunc("getClass"),
+    hid_t plist_class = H5Pget_class(id);
+    if(plist_class == H5P_ROOT)
+    {
+        throw PropListIException(inMemFunc("getClass"),
                 "H5Pget_class failed - returned H5P_ROOT");
-   }
-   return( plist_class );
+    }
+    return(plist_class);
 }
 
 //--------------------------------------------------------------------------
@@ -359,20 +359,20 @@ hid_t PropList::getClass() const
 ///             list or class.
 // Programmer:  Binh-Minh Ribler - April, 2004
 //--------------------------------------------------------------------------
-bool PropList::propExist(const char* name ) const
-{
-   // Calls C routine H5Pexist to determine whether a property exists
-   // within a property list or class.  It returns a positive value, 0,
-   // or a negative value
-   htri_t ret_value = H5Pexist(id, name);
-   if( ret_value > 0 )
-      return true;
-   else if( ret_value == 0 )
-      return false;
-   else // Raise exception when H5Pexist returns a negative value
-   {
-      throw PropListIException(inMemFunc("propExist"), "H5Pexist failed");
-   }
+bool PropList::propExist(const char* name) const
+{
+    // Calls C routine H5Pexist to determine whether a property exists
+    // within a property list or class.  It returns a positive value, 0,
+    // or a negative value
+    htri_t ret_value = H5Pexist(id, name);
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else // Raise exception when H5Pexist returns a negative value
+    {
+        throw PropListIException(inMemFunc("propExist"), "H5Pexist failed");
+    }
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::propExist
@@ -382,9 +382,9 @@ bool PropList::propExist(const char* name ) const
 ///\param       name - IN: Name of property to check for - \c H5std_string
 // Programmer:  Binh-Minh Ribler - April, 2004
 //--------------------------------------------------------------------------
-bool PropList::propExist(const H5std_string& name ) const
+bool PropList::propExist(const H5std_string& name) const
 {
-   return( propExist( name.c_str()) );
+    return(propExist(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -399,11 +399,11 @@ bool PropList::propExist(const H5std_string& name ) const
 //--------------------------------------------------------------------------
 void PropList::closeClass() const
 {
-   herr_t ret_value = H5Pclose_class(id);
-   if( ret_value < 0 )
-   {
-      throw PropListIException(inMemFunc("closeClass"), "H5Pclose_class failed");
-   }
+    herr_t ret_value = H5Pclose_class(id);
+    if(ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("closeClass"), "H5Pclose_class failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -420,11 +420,11 @@ void PropList::closeClass() const
 //--------------------------------------------------------------------------
 void PropList::getProperty(const char* name, void* value) const
 {
-   herr_t ret_value = H5Pget(id, name, value);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("getProperty"), "H5Pget failed");
-   }
+    herr_t ret_value = H5Pget(id, name, value);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("getProperty"), "H5Pget failed");
+    }
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::getProperty
@@ -438,26 +438,26 @@ void PropList::getProperty(const char* name, void* value) const
 //--------------------------------------------------------------------------
 H5std_string PropList::getProperty(const char* name) const
 {
-   // Get property size first
-   size_t size = getPropSize(name);
+    // Get property size first
+    size_t size = getPropSize(name);
 
-   // Allocate buffer then get the property
-   char* prop_strg_C = new char[size+1];  // temporary C-string for C API
-   HDmemset(prop_strg_C, 0, size+1); // clear buffer
+    // Allocate buffer then get the property
+    char* prop_strg_C = new char[size+1];  // temporary C-string for C API
+    HDmemset(prop_strg_C, 0, size+1); // clear buffer
 
-   herr_t ret_value = H5Pget(id, name, prop_strg_C); // call C API
+    herr_t ret_value = H5Pget(id, name, prop_strg_C); // call C API
 
-   // Throw exception if H5Pget returns failure
-   if (ret_value < 0)
-   {
+    // Throw exception if H5Pget returns failure
+    if (ret_value < 0)
+    {
       delete []prop_strg_C;
-      throw PropListIException(inMemFunc("getProperty"), "H5Pget failed");
-   }
+        throw PropListIException(inMemFunc("getProperty"), "H5Pget failed");
+    }
 
-   // Return propety value as a string after deleting temp C-string
-   H5std_string prop_strg(prop_strg_C);
-   delete []prop_strg_C;
-   return (prop_strg);
+    // Return propety value as a string after deleting temp C-string
+    H5std_string prop_strg(prop_strg_C);
+    delete []prop_strg_C;
+    return (prop_strg);
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::getProperty
@@ -470,7 +470,7 @@ H5std_string PropList::getProperty(const char* name) const
 //--------------------------------------------------------------------------
 void PropList::getProperty(const H5std_string& name, void* value) const
 {
-   getProperty(name.c_str(), value);
+    getProperty(name.c_str(), value);
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::getProperty
@@ -483,7 +483,7 @@ void PropList::getProperty(const H5std_string& name, void* value) const
 //--------------------------------------------------------------------------
 H5std_string PropList::getProperty(const H5std_string& name) const
 {
-   return (getProperty(name.c_str()));
+    return (getProperty(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -501,13 +501,13 @@ H5std_string PropList::getProperty(const H5std_string& name) const
 //--------------------------------------------------------------------------
 size_t PropList::getPropSize(const char *name) const
 {
-   size_t prop_size;
-   herr_t ret_value = H5Pget_size(id, name, &prop_size);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("getPropSize"), "H5Pget_size failed");
-   }
-   return(prop_size);
+    size_t prop_size;
+    herr_t ret_value = H5Pget_size(id, name, &prop_size);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("getPropSize"), "H5Pget_size failed");
+    }
+    return(prop_size);
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::getPropSize
@@ -520,7 +520,7 @@ size_t PropList::getPropSize(const char *name) const
 //--------------------------------------------------------------------------
 size_t PropList::getPropSize(const H5std_string& name) const
 {
-   return (getPropSize(name.c_str()));
+    return (getPropSize(name.c_str()));
 }
 
 //--------------------------------------------------------------------------
@@ -532,18 +532,18 @@ size_t PropList::getPropSize(const H5std_string& name) const
 //--------------------------------------------------------------------------
 H5std_string PropList::getClassName() const
 {
-   char* temp_str;
-   temp_str = H5Pget_class_name(id); // this API specified that temp_str must
+    char* temp_str;
+    temp_str = H5Pget_class_name(id); // this API specified that temp_str must
                                      // be freed.
 
-   if (temp_str != NULL)
-   {
-      H5std_string class_name(temp_str);
-      H5free_memory(temp_str);
-      return(class_name);
-   }
-   else
-      return 0;
+    if (temp_str != NULL)
+    {
+        H5std_string class_name(temp_str);
+        H5free_memory(temp_str);
+        return(class_name);
+    }
+    else
+        return 0;
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::getNumProps
@@ -554,13 +554,13 @@ H5std_string PropList::getClassName() const
 //--------------------------------------------------------------------------
 size_t PropList::getNumProps() const
 {
-   size_t nprops;
-   herr_t ret_value = H5Pget_nprops (id, &nprops);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("getNumProps"), "H5Pget_nprops failed");
-   }
-   return (nprops);
+    size_t nprops;
+    herr_t ret_value = H5Pget_nprops (id, &nprops);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("getNumProps"), "H5Pget_nprops failed");
+    }
+    return (nprops);
 }
 
 //--------------------------------------------------------------------------
@@ -573,11 +573,11 @@ size_t PropList::getNumProps() const
 //--------------------------------------------------------------------------
 void PropList::setProperty(const char* name, void* value) const
 {
-   herr_t ret_value = H5Pset(id, name, value);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("setProperty"), "H5Pset failed");
-   }
+    herr_t ret_value = H5Pset(id, name, value);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("setProperty"), "H5Pset failed");
+    }
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::setProperty
@@ -590,11 +590,11 @@ void PropList::setProperty(const char* name, void* value) const
 //--------------------------------------------------------------------------
 void PropList::setProperty(const char* name, const char* charptr) const
 {
-   herr_t ret_value = H5Pset(id, name, (void*)charptr);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("setProperty"), "H5Pset failed");
-   }
+    herr_t ret_value = H5Pset(id, name, (void*)charptr);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("setProperty"), "H5Pset failed");
+    }
 }
 //--------------------------------------------------------------------------
 // Function:    PropList::setProperty
@@ -607,7 +607,7 @@ void PropList::setProperty(const char* name, const char* charptr) const
 //--------------------------------------------------------------------------
 void PropList::setProperty(const char* name, H5std_string& strg) const
 {
-   setProperty(name, strg.c_str());
+    setProperty(name, strg.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -621,7 +621,7 @@ void PropList::setProperty(const char* name, H5std_string& strg) const
 //--------------------------------------------------------------------------
 void PropList::setProperty(const H5std_string& name, void* value) const
 {
-   setProperty(name.c_str(), value);
+    setProperty(name.c_str(), value);
 }
 
 //--------------------------------------------------------------------------
@@ -635,7 +635,7 @@ void PropList::setProperty(const H5std_string& name, void* value) const
 //--------------------------------------------------------------------------
 void PropList::setProperty(const H5std_string& name, H5std_string& strg) const
 {
-   setProperty(name.c_str(), strg.c_str());
+    setProperty(name.c_str(), strg.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -649,15 +649,15 @@ void PropList::setProperty(const H5std_string& name, H5std_string& strg) const
 //--------------------------------------------------------------------------
 bool PropList::isAClass(const PropList& prop_class) const
 {
-   htri_t ret_value = H5Pisa_class(id, prop_class.getId());
-   if( ret_value > 0 )
-      return true;
-   else if( ret_value == 0 )
-      return false;
-   else // Raise exception when H5Pisa_class returns a negative value
-   {
-      throw PropListIException(inMemFunc("isAClass"), "H5Pisa_class failed");
-   }
+    htri_t ret_value = H5Pisa_class(id, prop_class.getId());
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else // Raise exception when H5Pisa_class returns a negative value
+    {
+        throw PropListIException(inMemFunc("isAClass"), "H5Pisa_class failed");
+    }
 
 }
 
@@ -670,11 +670,11 @@ bool PropList::isAClass(const PropList& prop_class) const
 //--------------------------------------------------------------------------
 void PropList::removeProp(const char *name) const
 {
-   herr_t ret_value = H5Premove(id, name);
-   if (ret_value < 0)
-   {
-      throw PropListIException(inMemFunc("removeProp"), "H5Premove failed");
-   }
+    herr_t ret_value = H5Premove(id, name);
+    if (ret_value < 0)
+    {
+        throw PropListIException(inMemFunc("removeProp"), "H5Premove failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -687,7 +687,7 @@ void PropList::removeProp(const char *name) const
 //--------------------------------------------------------------------------
 void PropList::removeProp(const H5std_string& name) const
 {
-   removeProp(name.c_str());
+    removeProp(name.c_str());
 }
 
 //--------------------------------------------------------------------------
@@ -701,15 +701,15 @@ void PropList::removeProp(const H5std_string& name) const
 //--------------------------------------------------------------------------
 bool PropList::operator==(const PropList& rhs) const
 {
-   htri_t ret_value = H5Pequal(id, rhs.getId());
-   if( ret_value > 0 )
-      return true;
-   else if( ret_value == 0 )
-      return false;
-   else // Raise exception when H5Pequal returns a negative value
-   {
-      throw PropListIException(inMemFunc("operator=="), "H5Pequal failed");
-   }
+    htri_t ret_value = H5Pequal(id, rhs.getId());
+    if(ret_value > 0)
+        return true;
+    else if(ret_value == 0)
+        return false;
+    else // Raise exception when H5Pequal returns a negative value
+    {
+        throw PropListIException(inMemFunc("operator=="), "H5Pequal failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -721,13 +721,13 @@ bool PropList::operator==(const PropList& rhs) const
 //--------------------------------------------------------------------------
 PropList PropList::getClassParent() const
 {
-   hid_t class_id = H5Pget_class_parent(id);
-   if (class_id < 0)
-   {
-      throw PropListIException(inMemFunc("getClassParent"), "H5Pget_class_parent failed");
-   }
+    hid_t class_id = H5Pget_class_parent(id);
+    if (class_id < 0)
+    {
+        throw PropListIException(inMemFunc("getClassParent"), "H5Pget_class_parent failed");
+    }
    PropList pclass(class_id);
-   return(pclass);
+    return(pclass);
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5PropList.h b/c++/src/H5PropList.h
index 6ef43cf..4c50fb9 100644
--- a/c++/src/H5PropList.h
+++ b/c++/src/H5PropList.h
@@ -35,7 +35,7 @@ class H5_DLLCPP PropList : public IdComponent {
         PropList(const hid_t plist_id);
 
         // Make a copy of the given property list using assignment statement
-        PropList& operator=( const PropList& rhs );
+        PropList& operator=(const PropList& rhs);
 
         // Compares this property list or class against the given list or class.
         bool operator==(const PropList& rhs) const;
@@ -47,15 +47,15 @@ class H5_DLLCPP PropList : public IdComponent {
         void closeClass() const;
 
         // Makes a copy of the given property list.
-        void copy( const PropList& like_plist );
+        void copy(const PropList& like_plist);
 
         // Copies a property from this property list or class to another
-        void copyProp( PropList& dest, const char* name) const;
-        void copyProp( PropList& dest, const H5std_string& name) const;
+        void copyProp(PropList& dest, const char* name) const;
+        void copyProp(PropList& dest, const H5std_string& name) const;
 
         // Copies a property from one property list or property class to another
-        void copyProp( PropList& dest, PropList& src, const char* name) const;
-        void copyProp( PropList& dest, PropList& src, const H5std_string& name) const;
+        void copyProp(PropList& dest, PropList& src, const char* name) const;
+        void copyProp(PropList& dest, PropList& src, const H5std_string& name) const;
 
         // Gets the class of this property list, i.e. H5P_FILE_CREATE,
         // H5P_FILE_ACCESS, ...
diff --git a/c++/src/H5StrType.cpp b/c++/src/H5StrType.cpp
index 3638f99..ed60c6b 100644
--- a/c++/src/H5StrType.cpp
+++ b/c++/src/H5StrType.cpp
@@ -48,10 +48,10 @@ StrType::StrType() : AtomType() {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType::StrType( const PredType& pred_type ) : AtomType()
+StrType::StrType(const PredType& pred_type) : AtomType()
 {
-   // use DataType::copy to make a copy of this predefined type
-   copy( pred_type );
+    // use DataType::copy to make a copy of this predefined type
+    copy(pred_type);
 }
 
 //--------------------------------------------------------------------------
@@ -77,12 +77,12 @@ StrType::StrType( const PredType& pred_type ) : AtomType()
 //              Planned for removal. -BMR, 2005/12/02
 //              Removed from documentation. -BMR, 2016/03/07
 //--------------------------------------------------------------------------
-StrType::StrType( const PredType& pred_type, const size_t& size ) : AtomType()
+StrType::StrType(const PredType& pred_type, const size_t& size) : AtomType()
 {
-   // use DataType::copy to make a copy of the string predefined type
-   // then set its length
-   copy(pred_type);
-   setSize(size);
+    // use DataType::copy to make a copy of the string predefined type
+    // then set its length
+    copy(pred_type);
+    setSize(size);
 }
 
 //--------------------------------------------------------------------------
@@ -101,12 +101,12 @@ StrType::StrType( const PredType& pred_type, const size_t& size ) : AtomType()
 //              This constructor replaced the previous one.
 // Programmer   Binh-Minh Ribler - Nov 28, 2005
 //--------------------------------------------------------------------------
-StrType::StrType( const int dummy, const size_t& size ) : AtomType()
+StrType::StrType(const int dummy, const size_t& size) : AtomType()
 {
-   // use DataType::copy to make a copy of the string predefined type
-   // then set its length
-   copy(PredType::C_S1);
-   setSize(size);
+    // use DataType::copy to make a copy of the string predefined type
+    // then set its length
+    copy(PredType::C_S1);
+    setSize(size);
 }
 
 //--------------------------------------------------------------------------
@@ -116,14 +116,14 @@ StrType::StrType( const int dummy, const size_t& size ) : AtomType()
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType::StrType( const hid_t existing_id ) : AtomType( existing_id ) {}
+StrType::StrType(const hid_t existing_id) : AtomType(existing_id) {}
 
 //--------------------------------------------------------------------------
 // Function:    StrType copy constructor
 ///\brief       Copy constructor: makes a copy of the original StrType object.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType::StrType( const StrType& original ) : AtomType ( original ) {}
+StrType::StrType(const StrType& original) : AtomType (original) {}
 
 //--------------------------------------------------------------------------
 // Function:    StrType overloaded constructor
@@ -132,15 +132,15 @@ StrType::StrType( const StrType& original ) : AtomType ( original ) {}
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-StrType::StrType( const DataSet& dataset ) : AtomType ()
+StrType::StrType(const DataSet& dataset) : AtomType ()
 {
-   // Calls C function H5Dget_type to get the id of the datatype
-   id = H5Dget_type( dataset.getId() );
+    // Calls C function H5Dget_type to get the id of the datatype
+    id = H5Dget_type(dataset.getId());
 
-   if( id < 0 )
-   {
-      throw DataSetIException("StrType constructor", "H5Dget_type failed");
-   }
+    if(id < 0)
+    {
+        throw DataSetIException("StrType constructor", "H5Dget_type failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -160,14 +160,14 @@ StrType::StrType( const DataSet& dataset ) : AtomType ()
 //--------------------------------------------------------------------------
 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("StrType::getCset", "H5Tget_cset failed");
-   }
-   return( cset );
+    H5T_cset_t cset = H5Tget_cset(id);
+
+    // Returns a valid character set type if successful
+    if(cset == H5T_CSET_ERROR)
+    {
+        throw DataTypeIException("StrType::getCset", "H5Tget_cset failed");
+    }
+    return(cset);
 }
 
 //--------------------------------------------------------------------------
@@ -185,14 +185,14 @@ H5T_cset_t StrType::getCset() const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void StrType::setCset( H5T_cset_t cset ) const
+void StrType::setCset(H5T_cset_t cset) const
 {
-   herr_t ret_value = H5Tset_cset( id, cset );
+    herr_t ret_value = H5Tset_cset(id, cset);
 
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("StrType::setCset", "H5Tset_cset failed");
-   }
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("StrType::setCset", "H5Tset_cset failed");
+    }
 }
 
 //--------------------------------------------------------------------------
@@ -207,15 +207,15 @@ void StrType::setCset( H5T_cset_t cset ) const
 //--------------------------------------------------------------------------
 H5T_str_t StrType::getStrpad() const
 {
-   H5T_str_t strpad = H5Tget_strpad( id );
+    H5T_str_t strpad = H5Tget_strpad(id);
 
-   // Returns a valid string padding type if successful
-   if( strpad == H5T_STR_ERROR )
-   {
-      throw DataTypeIException("StrType::getStrpad",
+    // Returns a valid string padding type if successful
+    if(strpad == H5T_STR_ERROR)
+    {
+        throw DataTypeIException("StrType::getStrpad",
                 "H5Tget_strpad failed - returned H5T_STR_ERROR");
-   }
-   return( strpad );
+    }
+    return(strpad);
 }
 
 //--------------------------------------------------------------------------
@@ -228,14 +228,14 @@ H5T_str_t StrType::getStrpad() const
 /// http://www.hdfgroup.org/HDF5/doc/RM/RM_H5T.html#Datatype-SetStrpad
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void StrType::setStrpad( H5T_str_t strpad ) const
+void StrType::setStrpad(H5T_str_t strpad) const
 {
-   herr_t ret_value = H5Tset_strpad( id, strpad );
+    herr_t ret_value = H5Tset_strpad(id, strpad);
 
-   if( ret_value < 0 )
-   {
-      throw DataTypeIException("StrType::setStrpad", "H5Tset_strpad failed");
-   }
+    if(ret_value < 0)
+    {
+        throw DataTypeIException("StrType::setStrpad", "H5Tset_strpad failed");
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5VarLenType.cpp b/c++/src/H5VarLenType.cpp
index eb11d76..07508e4 100644
--- a/c++/src/H5VarLenType.cpp
+++ b/c++/src/H5VarLenType.cpp
@@ -64,12 +64,12 @@ VarLenType::VarLenType(const VarLenType& original) : DataType(original) {}
 //--------------------------------------------------------------------------
 VarLenType::VarLenType(const DataType* base_type) : DataType()
 {
-   id = H5Tvlen_create(base_type->getId());
-   if (id < 0)
-   {
-      throw DataTypeIException("VarLenType constructor",
+    id = H5Tvlen_create(base_type->getId());
+    if (id < 0)
+    {
+        throw DataTypeIException("VarLenType constructor",
                 "H5Tvlen_create returns negative value");
-   }
+    }
 }
 
 //--------------------------------------------------------------------------
diff --git a/c++/src/H5VarLenType.h b/c++/src/H5VarLenType.h
index 7a2cfc1..2676fb3 100644
--- a/c++/src/H5VarLenType.h
+++ b/c++/src/H5VarLenType.h
@@ -34,10 +34,10 @@ class H5_DLLCPP VarLenType : public DataType {
         virtual H5std_string fromClass () const { return("VarLenType"); }
 
         // Copy constructor: makes copy of the original object.
-        VarLenType( const VarLenType& original );
+        VarLenType(const VarLenType& original);
 
         // Constructor that takes an existing id
-        VarLenType( const hid_t existing_id );
+        VarLenType(const hid_t existing_id);
 
         // Noop destructor
         virtual ~VarLenType();