Clang-format of source files

1 files changed, 40 insertions, 41 deletions

diff --git a/c++/src/H5AtomType.cpp b/c++/src/H5AtomType.cpp
index 9408452..abebc3b 100644
--- a/c++/src/H5AtomType.cpp
+++ b/c++/src/H5AtomType.cpp
@@ -51,7 +51,7 @@ AtomType::AtomType(const hid_t existing_id) : DataType(existing_id) {}
 ///\brief       Copy constructor: same HDF5 object as \a original
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-AtomType::AtomType(const AtomType& original) : DataType(original) {}
+AtomType::AtomType(const AtomType &original) : DataType(original) {}
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
 //--------------------------------------------------------------------------
@@ -61,12 +61,12 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("setSize"), "H5Tset_size failed");
     }
 }
@@ -81,18 +81,17 @@ void AtomType::setSize(size_t size) const
 ///\exception   H5::DataTypeIException
 // Programmer   Binh-Minh Ribler - Mar, 2005
 //--------------------------------------------------------------------------
-H5T_order_t AtomType::getOrder() const
+H5T_order_t
+AtomType::getOrder() const
 {
     // Call C routine to get the byte ordering
     H5T_order_t type_order = H5Tget_order(id);
 
     // return a byte order constant if successful
-    if (type_order == H5T_ORDER_ERROR)
-    {
-        throw DataTypeIException(inMemFunc("getOrder"),
-             "H5Tget_order returns H5T_ORDER_ERROR");
+    if (type_order == H5T_ORDER_ERROR) {
+        throw DataTypeIException(inMemFunc("getOrder"), "H5Tget_order returns H5T_ORDER_ERROR");
     }
-   return(type_order);
+    return (type_order);
 }
 
 //--------------------------------------------------------------------------
@@ -112,7 +111,8 @@ 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();
@@ -124,7 +124,7 @@ H5T_order_t AtomType::getOrder(H5std_string& order_string) const
         order_string = "Big endian byte ordering (1)";
     else if (type_order == H5T_ORDER_VAX)
         order_string = "VAX mixed byte ordering (2)";
-    return(type_order);
+    return (type_order);
 }
 
 //--------------------------------------------------------------------------
@@ -137,12 +137,12 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("setOrder"), "H5Tset_order failed");
     }
 }
@@ -158,17 +158,17 @@ void AtomType::setOrder(H5T_order_t order) const
 ///             value returned by \c DataType::getSize().
 // Programmer   Binh-Minh Ribler - 2000
 //--------------------------------------------------------------------------
-size_t AtomType::getPrecision() 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)
-    {
+    if (num_signi_bits == 0) {
         throw DataTypeIException(inMemFunc("getPrecision"),
-             "H5Tget_precision returns invalid number of significant bits");
+                                 "H5Tget_precision returns invalid number of significant bits");
     }
-    return(num_signi_bits);
+    return (num_signi_bits);
 }
 
 //--------------------------------------------------------------------------
@@ -181,12 +181,12 @@ size_t AtomType::getPrecision() const
 ///             the HDF5 C Reference Manual.
 // 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("setPrecision"), "H5Tset_precision failed");
     }
 }
@@ -205,17 +205,16 @@ void AtomType::setPrecision(size_t precision) const
 //                  - return type changed from size_t to int
 //                  - offset = -1 when failure occurs vs. 0
 //--------------------------------------------------------------------------
-int AtomType::getOffset() 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"),
-             "H5Tget_offset returns a negative offset value");
+    if (offset == -1) {
+        throw DataTypeIException(inMemFunc("getOffset"), "H5Tget_offset returns a negative offset value");
     }
-    return(offset);
+    return (offset);
 }
 
 //--------------------------------------------------------------------------
@@ -228,12 +227,12 @@ int AtomType::getOffset() const
 ///             the HDF5 C Reference Manual.
 // 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("setOffset"), "H5Tset_offset failed");
     }
 }
@@ -252,12 +251,12 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("getPad"), "H5Tget_pad failed");
     }
 }
@@ -275,12 +274,12 @@ 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)
-    {
+    if (ret_value < 0) {
         throw DataTypeIException(inMemFunc("setPad"), "H5Tset_pad failed");
     }
 }
@@ -294,4 +293,4 @@ void AtomType::setPad(H5T_pad_t lsb, H5T_pad_t msb) const
 AtomType::~AtomType() {}
 #endif // DOXYGEN_SHOULD_SKIP_THIS
 
-} // end namespace
+} // namespace H5