Clang-format of source files

1 files changed, 126 insertions, 125 deletions

diff --git a/c++/src/H5DataSpace.cpp b/c++/src/H5DataSpace.cpp
index e8e5712..47fdbbc 100644
--- a/c++/src/H5DataSpace.cpp
+++ b/c++/src/H5DataSpace.cpp
@@ -33,7 +33,7 @@ using std::endl;
 // in "H5PredType.cpp" for information.
 
 // Initialize a pointer for the constant
-DataSpace* DataSpace::ALL_ = 0;
+DataSpace *DataSpace::ALL_ = 0;
 
 //--------------------------------------------------------------------------
 // Function:    DataSpace::getConstant
@@ -45,13 +45,13 @@ DataSpace* DataSpace::ALL_ = 0;
 //              a DataSpaceIException.  This scenario should not happen.
 // Programmer   Binh-Minh Ribler - 2015
 //--------------------------------------------------------------------------
-DataSpace* DataSpace::getConstant()
+DataSpace *
+DataSpace::getConstant()
 {
     // Tell the C library not to clean up, H5Library::termH5cpp will call
     // H5close - more dependency if use H5Library::dontAtExit()
-    if (!IdComponent::H5dontAtexit_called)
-    {
-        (void) H5dont_atexit();
+    if (!IdComponent::H5dontAtexit_called) {
+        (void)H5dont_atexit();
         IdComponent::H5dontAtexit_called = true;
     }
 
@@ -60,8 +60,9 @@ DataSpace* DataSpace::getConstant()
     if (ALL_ == 0)
         ALL_ = new DataSpace(H5S_ALL);
     else
-        throw DataSpaceIException("DataSpace::getConstant", "DataSpace::getConstant is being invoked on an allocated ALL_");
-    return(ALL_);
+        throw DataSpaceIException("DataSpace::getConstant",
+                                  "DataSpace::getConstant is being invoked on an allocated ALL_");
+    return (ALL_);
 }
 
 //--------------------------------------------------------------------------
@@ -69,7 +70,8 @@ DataSpace* DataSpace::getConstant()
 // Purpose:     Deletes the constant object that DataSpace::ALL_ points to
 // Programmer   Binh-Minh Ribler - 2015
 //--------------------------------------------------------------------------
-void DataSpace::deleteConstants()
+void
+DataSpace::deleteConstants()
 {
     if (ALL_ != 0)
         delete ALL_;
@@ -78,7 +80,7 @@ void DataSpace::deleteConstants()
 //--------------------------------------------------------------------------
 // Purpose      Constant for default dataspace.
 //--------------------------------------------------------------------------
-const DataSpace& DataSpace::ALL = *getConstant();
+const DataSpace &DataSpace::ALL = *getConstant();
 
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
@@ -94,8 +96,7 @@ const DataSpace& DataSpace::ALL = *getConstant();
 DataSpace::DataSpace(H5S_class_t type) : IdComponent()
 {
     id = H5Screate(type);
-    if (id < 0)
-    {
+    if (id < 0) {
         throw DataSpaceIException("DataSpace constructor", "H5Screate failed");
     }
 }
@@ -109,11 +110,10 @@ 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)
-    {
+    if (id < 0) {
         throw DataSpaceIException("DataSpace constructor", "H5Screate_simple failed");
     }
 }
@@ -137,7 +137,7 @@ DataSpace::DataSpace(const hid_t existing_id) : IdComponent(), id(existing_id)
 ///\param       original - IN: DataSpace object to copy
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-DataSpace::DataSpace(const DataSpace& original) : IdComponent(), id(original.id)
+DataSpace::DataSpace(const DataSpace &original) : IdComponent(), id(original.id)
 {
     incRefCount(); // increment number of references to this id
 }
@@ -154,17 +154,18 @@ 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 {
             close();
         }
-        catch (Exception& close_error) {
-         throw DataSpaceIException("DataSpace::copy", close_error.getDetailMsg());
+        catch (Exception &close_error) {
+            throw DataSpaceIException("DataSpace::copy", close_error.getDetailMsg());
         }
-    }  // end if
+    } // end if
 
     // call C routine to copy the dataspace
     id = H5Scopy(like_space.getId());
@@ -184,11 +185,12 @@ 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);
-    return(*this);
+    return (*this);
 }
 
 //--------------------------------------------------------------------------
@@ -199,17 +201,16 @@ DataSpace& DataSpace::operator=(const DataSpace& rhs)
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-bool DataSpace::isSimple () const
+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",
-            "H5Sis_simple returns negative value");
+    else {
+        throw DataSpaceIException("DataSpace::isSimple", "H5Sis_simple returns negative value");
     }
 }
 
@@ -225,11 +226,11 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataSpaceIException("DataSpace::offsetSimple", "H5Soffset_simple failed");
     }
 }
@@ -244,15 +245,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)
-    {
+    if (ndims < 0) {
         throw DataSpaceIException("DataSpace::getSimpleExtentDims",
-            "H5Sget_simple_extent_dims returns negative number of dimensions");
+                                  "H5Sget_simple_extent_dims returns negative number of dimensions");
     }
-    return(ndims);
+    return (ndims);
 }
 
 //--------------------------------------------------------------------------
@@ -262,15 +263,16 @@ int DataSpace::getSimpleExtentDims (hsize_t *dims, hsize_t *maxdims) const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-int DataSpace::getSimpleExtentNdims () const
+int
+DataSpace::getSimpleExtentNdims() const
 {
     int ndims = H5Sget_simple_extent_ndims(id);
-    if (ndims < 0)
-    {
-        throw DataSpaceIException("DataSpace::getSimpleExtentNdims",
+    if (ndims < 0) {
+        throw DataSpaceIException(
+            "DataSpace::getSimpleExtentNdims",
             "H5Sget_simple_extent_ndims returns negative value for dimensionality of the dataspace");
     }
-    return(ndims);
+    return (ndims);
 }
 
 //--------------------------------------------------------------------------
@@ -284,15 +286,16 @@ int DataSpace::getSimpleExtentNdims () const
 //                      num_elements = -1 when failure occurs vs. 0
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-hssize_t DataSpace::getSimpleExtentNpoints () const
+hssize_t
+DataSpace::getSimpleExtentNpoints() const
 {
     hssize_t num_elements = H5Sget_simple_extent_npoints(id);
     if (num_elements > -1)
-        return(num_elements);
-    else
-    {
+        return (num_elements);
+    else {
         throw DataSpaceIException("DataSpace::getSimpleExtentNpoints",
-        "H5Sget_simple_extent_npoints returns negative value for the number of elements in the dataspace");
+                                  "H5Sget_simple_extent_npoints returns negative value for the number of "
+                                  "elements in the dataspace");
     }
 }
 
@@ -303,15 +306,15 @@ hssize_t DataSpace::getSimpleExtentNpoints () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-H5S_class_t DataSpace::getSimpleExtentType () const
+H5S_class_t
+DataSpace::getSimpleExtentType() const
 {
     H5S_class_t class_name = H5Sget_simple_extent_type(id);
-    if (class_name == H5S_NO_CLASS)
-    {
+    if (class_name == H5S_NO_CLASS) {
         throw DataSpaceIException("DataSpace::getSimpleExtentType",
-            "H5Sget_simple_extent_type returns H5S_NO_CLASS");
+                                  "H5Sget_simple_extent_type returns H5S_NO_CLASS");
     }
-    return(class_name);
+    return (class_name);
 }
 
 //--------------------------------------------------------------------------
@@ -321,12 +324,12 @@ H5S_class_t DataSpace::getSimpleExtentType () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::extentCopy (const DataSpace& dest_space) 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)
-    {
+    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");
     }
 }
@@ -344,7 +347,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);
 //}
@@ -358,12 +361,12 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataSpaceIException("DataSpace::setExtentSimple", "H5Sset_extent_simple failed");
     }
 }
@@ -375,11 +378,11 @@ void DataSpace::setExtentSimple(int rank, const hsize_t *current_size, const hsi
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::setExtentNone () const
+void
+DataSpace::setExtentNone() const
 {
     herr_t ret_value = H5Sset_extent_none(id);
-    if (ret_value < 0)
-    {
+    if (ret_value < 0) {
         throw DataSpaceIException("DataSpace::setExtentNone", "H5Sset_extent_none failed");
     }
 }
@@ -391,15 +394,16 @@ void DataSpace::setExtentNone () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-hssize_t DataSpace::getSelectNpoints () const
+hssize_t
+DataSpace::getSelectNpoints() const
 {
     hssize_t num_elements = H5Sget_select_npoints(id);
-    if (num_elements < 0)
-    {
-        throw DataSpaceIException("DataSpace::getSelectNpoints",
+    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);
 }
 
 //--------------------------------------------------------------------------
@@ -409,15 +413,16 @@ hssize_t DataSpace::getSelectNpoints () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-hssize_t DataSpace::getSelectHyperNblocks () const
+hssize_t
+DataSpace::getSelectHyperNblocks() const
 {
     hssize_t num_blocks = H5Sget_select_hyper_nblocks(id);
-    if (num_blocks < 0)
-    {
-        throw DataSpaceIException("DataSpace::getSelectHyperNblocks",
+    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);
 }
 
 //--------------------------------------------------------------------------
@@ -429,14 +434,14 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataSpaceIException("DataSpace::getSelectHyperBlocklist",
-            "H5Sget_select_hyper_blocklist failed");
+                                  "H5Sget_select_hyper_blocklist failed");
     }
 }
 
@@ -447,15 +452,14 @@ void DataSpace::getSelectHyperBlocklist(hsize_t startblock, hsize_t numblocks, h
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-hssize_t DataSpace::getSelectElemNpoints () const
+hssize_t
+DataSpace::getSelectElemNpoints() const
 {
     hssize_t num_points = H5Sget_select_elem_npoints(id);
-    if (num_points < 0)
-    {
-        throw DataSpaceIException("DataSpace::getSelectElemNpoints",
-            "H5Sget_select_elem_npoints failed");
+    if (num_points < 0) {
+        throw DataSpaceIException("DataSpace::getSelectElemNpoints", "H5Sget_select_elem_npoints failed");
     }
-    return(num_points);
+    return (num_points);
 }
 
 //--------------------------------------------------------------------------
@@ -470,14 +474,13 @@ hssize_t DataSpace::getSelectElemNpoints () const
 ///             H5Sget_select_elem_pointlist in the HDF5 C Reference Manual.
 // 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",
-            "H5Sget_select_elem_pointlist failed");
+    if (ret_value < 0) {
+        throw DataSpaceIException("DataSpace::getSelectElemPointlist", "H5Sget_select_elem_pointlist failed");
     }
 }
 
@@ -493,13 +496,12 @@ void DataSpace::getSelectElemPointlist (hsize_t startpoint, hsize_t numpoints, h
 ///             the HDF5 C Reference Manual.
 // 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",
-            "H5Sget_select_bounds failed");
+    if (ret_value < 0) {
+        throw DataSpaceIException("DataSpace::getSelectBounds", "H5Sget_select_bounds failed");
     }
 }
 
@@ -518,14 +520,13 @@ void DataSpace::getSelectBounds (hsize_t* start, hsize_t* end) const
 ///             the HDF5 C Reference Manual.
 // 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",
-            "H5Sselect_elements failed");
+    if (ret_value < 0) {
+        throw DataSpaceIException("DataSpace::selectElements", "H5Sselect_elements failed");
     }
 }
 
@@ -536,11 +537,11 @@ void DataSpace::selectElements (H5S_seloper_t op, const size_t num_elements, con
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::selectAll () const
+void
+DataSpace::selectAll() const
 {
     herr_t ret_value = H5Sselect_all(id);
-    if (ret_value < 0)
-    {
+    if (ret_value < 0) {
         throw DataSpaceIException("DataSpace::selectAll", "H5Sselect_all failed");
     }
 }
@@ -552,13 +553,12 @@ void DataSpace::selectAll () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::selectNone () const
+void
+DataSpace::selectNone() const
 {
     herr_t ret_value = H5Sselect_none(id);
-    if (ret_value < 0)
-    {
-        throw DataSpaceIException("DataSpace::selectNone",
-            "H5Sselect_none failed");
+    if (ret_value < 0) {
+        throw DataSpaceIException("DataSpace::selectNone", "H5Sselect_none failed");
     }
 }
 
@@ -571,17 +571,16 @@ void DataSpace::selectNone () const
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-bool DataSpace::selectValid () 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",
-            "H5Sselect_valid returns negative value");
+    else {
+        throw DataSpaceIException("DataSpace::selectValid", "H5Sselect_valid returns negative value");
     }
 }
 
@@ -599,14 +598,14 @@ bool DataSpace::selectValid () const
 ///             the HDF5 C Reference Manual.
 // 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",
-            "H5Sselect_hyperslab failed");
+    if (ret_value < 0) {
+        throw DataSpaceIException("DataSpace::selectHyperslab", "H5Sselect_hyperslab failed");
     }
 }
 
@@ -622,9 +621,10 @@ void DataSpace::selectHyperslab(H5S_seloper_t op, const hsize_t *count, const hs
 //              IdComponent::getId now becomes pure virtual function.
 // Programmer   Binh-Minh Ribler - May, 2008
 //--------------------------------------------------------------------------
-hid_t DataSpace::getId() const
+hid_t
+DataSpace::getId() const
 {
-    return(id);
+    return (id);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -640,13 +640,14 @@ hid_t DataSpace::getId() const
 //              Then the object's id is reset to the new id.
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-void DataSpace::p_setId(const hid_t new_id)
+void
+DataSpace::p_setId(const hid_t new_id)
 {
     // handling references to this old id
     try {
         close();
     }
-    catch (Exception& close_error) {
+    catch (Exception &close_error) {
         throw DataSpaceIException(inMemFunc("p_setId"), close_error.getDetailMsg());
     }
     // reset object's id to the given id
@@ -661,14 +662,13 @@ void DataSpace::p_setId(const hid_t new_id)
 ///\exception   H5::DataSpaceIException
 // Programmer   Binh-Minh Ribler - Mar 9, 2005
 //--------------------------------------------------------------------------
-void DataSpace::close()
+void
+DataSpace::close()
 {
     // check if id is a valid hdf5 object id before trying to close it
-    if (p_valid_id(id))
-    {
+    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");
         }
         // reset the id
@@ -690,9 +690,10 @@ DataSpace::~DataSpace()
 {
     try {
         close();
-    } catch (Exception& close_error) {
+    }
+    catch (Exception &close_error) {
         cerr << "DataSpace::~DataSpace - " << close_error.getDetailMsg() << endl;
     }
 }
 
-} // end namespace
+} // namespace H5