Clang-format of source files

1 files changed, 264 insertions, 290 deletions

diff --git a/src/H5FDhdfs.c b/src/H5FDhdfs.c
index 29d032e..569b889 100644
--- a/src/H5FDhdfs.c
+++ b/src/H5FDhdfs.c
@@ -20,13 +20,13 @@
  *             File System (HDFS).
  */
 
-#include "H5private.h"      /* Generic Functions        */
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDhdfs.h"       /* hdfs file driver         */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
+#include "H5private.h"   /* Generic Functions        */
+#include "H5Eprivate.h"  /* Error handling           */
+#include "H5FDprivate.h" /* File drivers             */
+#include "H5FDhdfs.h"    /* hdfs file driver         */
+#include "H5FLprivate.h" /* Free Lists               */
+#include "H5Iprivate.h"  /* IDs                      */
+#include "H5MMprivate.h" /* Memory management        */
 
 #ifdef H5_HAVE_LIBHDFS
 
@@ -60,35 +60,32 @@ static hid_t H5FD_HDFS_g = 0;
  * 2^(10+(1*16)) = 2^26 = 64MB
  *     Reads of 64MB or greater fall in "overflow" bin[BIN_COUNT]
  */
-#define HDFS_STATS_BASE         2
-#define HDFS_STATS_INTERVAL     1
+#define HDFS_STATS_BASE        2
+#define HDFS_STATS_INTERVAL    1
 #define HDFS_STATS_START_POWER 10
 #define HDFS_STATS_BIN_COUNT   16 /* MUST BE GREATER THAN 0 */
 
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Calculate `BASE ^ (START_POWER + (INTERVAL * bin_i))`
  * Stores result at `(unsigned long long *) out_ptr`.
  * Used in computing boundaries between stats bins.
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  */
-#define HDFS_STATS_POW(bin_i, out_ptr) {                       \
-    unsigned long long donotshadowresult = 1;                  \
-    unsigned           donotshadowindex  = 0;                  \
-    for(donotshadowindex = 0;                                  \
-         donotshadowindex < (((bin_i) * HDFS_STATS_INTERVAL) + \
-                              HDFS_STATS_START_POWER);         \
-         donotshadowindex++)                                   \
-    {                                                          \
-        donotshadowresult *= HDFS_STATS_BASE;                  \
-    }                                                          \
-    *(out_ptr) = donotshadowresult;                            \
-}
+#define HDFS_STATS_POW(bin_i, out_ptr)                                                                       \
+    {                                                                                                        \
+        unsigned long long donotshadowresult = 1;                                                            \
+        unsigned           donotshadowindex  = 0;                                                            \
+        for (donotshadowindex = 0;                                                                           \
+             donotshadowindex < (((bin_i)*HDFS_STATS_INTERVAL) + HDFS_STATS_START_POWER);                    \
+             donotshadowindex++) {                                                                           \
+            donotshadowresult *= HDFS_STATS_BASE;                                                            \
+        }                                                                                                    \
+        *(out_ptr) = donotshadowresult;                                                                      \
+    }
 
 /* array to hold pre-computed boundaries for stats bins */
 static unsigned long long hdfs_stats_boundaries[HDFS_STATS_BIN_COUNT];
 
-
 /***************************************************************************
  *
  * Structure: hdfs_statsbin
@@ -129,13 +126,11 @@ typedef struct {
 
 #endif /* HDFS_STATS */
 
-
 /* "unique" identifier for `hdfs_t` structures.
  * Randomly generated by unweighted dice rolls.
  */
 #define HDFS_HDFST_MAGIC 0x1AD5DE84
 
-
 /***************************************************************************
  *
  * Structure: hdfs_t
@@ -174,14 +169,12 @@ typedef struct {
  ***************************************************************************
  */
 typedef struct {
-    unsigned long  magic;
-    hdfsFS         filesystem;
-    hdfsFileInfo  *fileinfo;
-    hdfsFile       file;
+    unsigned long magic;
+    hdfsFS        filesystem;
+    hdfsFileInfo *fileinfo;
+    hdfsFile      file;
 } hdfs_t;
 
-
-
 /***************************************************************************
  *
  * Structure: H5FD_hdfs_t
@@ -241,13 +234,13 @@ typedef struct {
  ***************************************************************************
  */
 typedef struct H5FD_hdfs_t {
-    H5FD_t            pub;
-    H5FD_hdfs_fapl_t  fa;
-    haddr_t           eoa;
-    hdfs_t           *hdfs_handle;
+    H5FD_t           pub;
+    H5FD_hdfs_fapl_t fa;
+    haddr_t          eoa;
+    hdfs_t *         hdfs_handle;
 #if HDFS_STATS
-    hdfs_statsbin     meta[HDFS_STATS_BIN_COUNT + 1];
-    hdfs_statsbin     raw[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin meta[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin raw[HDFS_STATS_BIN_COUNT + 1];
 #endif
 } H5FD_hdfs_t;
 
@@ -261,74 +254,70 @@ typedef struct H5FD_hdfs_t {
  *                  Only included if HDFS code should compile.
  *
  */
-#define MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
-#define ADDR_OVERFLOW(A)    (HADDR_UNDEF==(A) || ((A) & ~(haddr_t)MAXADDR))
+#define MAXADDR          (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
 
 /* Prototypes */
 static herr_t  H5FD__hdfs_term(void);
-static void   *H5FD__hdfs_fapl_get(H5FD_t *_file);
-static void   *H5FD__hdfs_fapl_copy(const void *_old_fa);
+static void *  H5FD__hdfs_fapl_get(H5FD_t *_file);
+static void *  H5FD__hdfs_fapl_copy(const void *_old_fa);
 static herr_t  H5FD__hdfs_fapl_free(void *_fa);
-static H5FD_t *H5FD__hdfs_open(const char *name, unsigned flags, hid_t fapl_id,
-                              haddr_t maxaddr);
+static H5FD_t *H5FD__hdfs_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
 static herr_t  H5FD__hdfs_close(H5FD_t *_file);
 static int     H5FD__hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
 static herr_t  H5FD__hdfs_query(const H5FD_t *_f1, unsigned long *flags);
 static haddr_t H5FD__hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
 static herr_t  H5FD__hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
 static haddr_t H5FD__hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD__hdfs_get_handle(H5FD_t *_file, hid_t fapl,
-                                    void** file_handle);
-static herr_t  H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-                               haddr_t addr, size_t size, void *buf);
-static herr_t  H5FD__hdfs_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-                               haddr_t addr, size_t size, const void *buf);
-static herr_t  H5FD__hdfs_truncate(H5FD_t *_file, hid_t dxpl_id,
-                                  hbool_t closing);
+static herr_t  H5FD__hdfs_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle);
+static herr_t  H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                               void *buf);
+static herr_t  H5FD__hdfs_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                                const void *buf);
+static herr_t  H5FD__hdfs_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
 static herr_t  H5FD__hdfs_lock(H5FD_t *_file, hbool_t rw);
 static herr_t  H5FD__hdfs_unlock(H5FD_t *_file);
 
-static herr_t  H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t * fa);
+static herr_t H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t *fa);
 
 static const H5FD_class_t H5FD_hdfs_g = {
-    "hdfs",                     /* name                 */
-    MAXADDR,                    /* maxaddr              */
-    H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD__hdfs_term,            /* terminate            */
-    NULL,                       /* sb_size              */
-    NULL,                       /* sb_encode            */
-    NULL,                       /* sb_decode            */
-    sizeof(H5FD_hdfs_fapl_t),   /* fapl_size            */
-    H5FD__hdfs_fapl_get,        /* fapl_get             */
-    H5FD__hdfs_fapl_copy,       /* fapl_copy            */
-    H5FD__hdfs_fapl_free,       /* fapl_free            */
-    0,                          /* dxpl_size            */
-    NULL,                       /* dxpl_copy            */
-    NULL,                       /* dxpl_free            */
-    H5FD__hdfs_open,            /* open                 */
-    H5FD__hdfs_close,           /* close                */
-    H5FD__hdfs_cmp,             /* cmp                  */
-    H5FD__hdfs_query,           /* query                */
-    NULL,                       /* get_type_map         */
-    NULL,                       /* alloc                */
-    NULL,                       /* free                 */
-    H5FD__hdfs_get_eoa,         /* get_eoa              */
-    H5FD__hdfs_set_eoa,         /* set_eoa              */
-    H5FD__hdfs_get_eof,         /* get_eof              */
-    H5FD__hdfs_get_handle,      /* get_handle           */
-    H5FD__hdfs_read,            /* read                 */
-    H5FD__hdfs_write,           /* write                */
-    NULL,                       /* flush                */
-    H5FD__hdfs_truncate,        /* truncate             */
-    H5FD__hdfs_lock,            /* lock                 */
-    H5FD__hdfs_unlock,          /* unlock               */
-    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
+    "hdfs",                   /* name                 */
+    MAXADDR,                  /* maxaddr              */
+    H5F_CLOSE_WEAK,           /* fc_degree            */
+    H5FD__hdfs_term,          /* terminate            */
+    NULL,                     /* sb_size              */
+    NULL,                     /* sb_encode            */
+    NULL,                     /* sb_decode            */
+    sizeof(H5FD_hdfs_fapl_t), /* fapl_size            */
+    H5FD__hdfs_fapl_get,      /* fapl_get             */
+    H5FD__hdfs_fapl_copy,     /* fapl_copy            */
+    H5FD__hdfs_fapl_free,     /* fapl_free            */
+    0,                        /* dxpl_size            */
+    NULL,                     /* dxpl_copy            */
+    NULL,                     /* dxpl_free            */
+    H5FD__hdfs_open,          /* open                 */
+    H5FD__hdfs_close,         /* close                */
+    H5FD__hdfs_cmp,           /* cmp                  */
+    H5FD__hdfs_query,         /* query                */
+    NULL,                     /* get_type_map         */
+    NULL,                     /* alloc                */
+    NULL,                     /* free                 */
+    H5FD__hdfs_get_eoa,       /* get_eoa              */
+    H5FD__hdfs_set_eoa,       /* set_eoa              */
+    H5FD__hdfs_get_eof,       /* get_eof              */
+    H5FD__hdfs_get_handle,    /* get_handle           */
+    H5FD__hdfs_read,          /* read                 */
+    H5FD__hdfs_write,         /* write                */
+    NULL,                     /* flush                */
+    H5FD__hdfs_truncate,      /* truncate             */
+    H5FD__hdfs_lock,          /* lock                 */
+    H5FD__hdfs_unlock,        /* unlock               */
+    H5FD_FLMAP_DICHOTOMY      /* fl_map               */
 };
 
 /* Declare a free list to manage the H5FD_hdfs_t struct */
 H5FL_DEFINE_STATIC(H5FD_hdfs_t);
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
  *
@@ -345,14 +334,13 @@ H5FD__init_package(void)
 
     FUNC_ENTER_STATIC
 
-    if(H5FD_hdfs_init() < 0)
+    if (H5FD_hdfs_init() < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize hdfs VFD")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__init_package() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_init
  *
@@ -380,13 +368,13 @@ H5FD_hdfs_init(void)
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif
 
-    if(H5I_VFL != H5I_get_type(H5FD_HDFS_g))
+    if (H5I_VFL != H5I_get_type(H5FD_HDFS_g))
         H5FD_HDFS_g = H5FD_register(&H5FD_hdfs_g, sizeof(H5FD_class_t), FALSE);
 
 #if HDFS_STATS
     /* pre-compute statsbin boundaries
      */
-    for(bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
+    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
         unsigned long long value = 0;
 
         HDFS_STATS_POW(bin_i, &value)
@@ -400,7 +388,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_hdfs_init() */
 
-
 /*---------------------------------------------------------------------------
  * Function:    H5FD__hdfs_term
  *
@@ -428,7 +415,6 @@ H5FD__hdfs_term(void)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD__hdfs_term() */
 
-
 /*--------------------------------------------------------------------------
  * Function:   H5FD__hdfs_handle_open
  *
@@ -443,13 +429,13 @@ H5FD__hdfs_term(void)
  *--------------------------------------------------------------------------
  */
 static hdfs_t *
-H5FD__hdfs_handle_open(const char *path, const char *namenode_name,
-    const int32_t namenode_port, const char *user_name,
-    const char *kerberos_ticket_cache, const int32_t stream_buffer_size)
+H5FD__hdfs_handle_open(const char *path, const char *namenode_name, const int32_t namenode_port,
+                       const char *user_name, const char *kerberos_ticket_cache,
+                       const int32_t stream_buffer_size)
 {
     struct hdfsBuilder *builder   = NULL;
-    hdfs_t             *handle    = NULL;
-    hdfs_t             *ret_value = NULL;
+    hdfs_t *            handle    = NULL;
+    hdfs_t *            ret_value = NULL;
 
     FUNC_ENTER_STATIC
 
@@ -457,17 +443,17 @@ H5FD__hdfs_handle_open(const char *path, const char *namenode_name,
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif
 
-    if(path == NULL || path[0] == '\0')
+    if (path == NULL || path[0] == '\0')
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "path cannot be null")
-    if(namenode_name == NULL)
+    if (namenode_name == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode name cannot be null")
-    if(namenode_port < 0 || namenode_port > 65535)
+    if (namenode_port < 0 || namenode_port > 65535)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode port must be non-negative and <= 65535")
-    if(stream_buffer_size < 0)
+    if (stream_buffer_size < 0)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "buffer size must non-negative")
 
     handle = (hdfs_t *)H5MM_malloc(sizeof(hdfs_t));
-    if(handle == NULL)
+    if (handle == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_CANTALLOC, NULL, "could not malloc space for handle")
 
     handle->magic      = (unsigned long)HDFS_HDFST_MAGIC;
@@ -476,40 +462,40 @@ H5FD__hdfs_handle_open(const char *path, const char *namenode_name,
     handle->file       = NULL; /* TODO: not a pointer; NULL may cause bug */
 
     builder = hdfsNewBuilder();
-    if(!builder)
+    if (!builder)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) failed to create builder")
     hdfsBuilderSetNameNode(builder, namenode_name);
     hdfsBuilderSetNameNodePort(builder, (tPort)namenode_port);
-    if(user_name != NULL && user_name[0] != '\0')
+    if (user_name != NULL && user_name[0] != '\0')
         hdfsBuilderSetUserName(builder, user_name);
-    if(kerberos_ticket_cache != NULL && kerberos_ticket_cache[0] != '\0')
+    if (kerberos_ticket_cache != NULL && kerberos_ticket_cache[0] != '\0')
         hdfsBuilderSetKerbTicketCachePath(builder, kerberos_ticket_cache);
 
     /* Call to `hdfsBuilderConnect` releases builder, regardless of success. */
     handle->filesystem = hdfsBuilderConnect(builder);
-    if(!handle->filesystem)
+    if (!handle->filesystem)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) could not connect to default namenode")
     handle->fileinfo = hdfsGetPathInfo(handle->filesystem, path);
-    if(!handle->fileinfo)
+    if (!handle->fileinfo)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "hdfsGetPathInfo failed")
     handle->file = hdfsOpenFile(handle->filesystem, path, O_RDONLY, stream_buffer_size, 0, 0);
-    if(!handle->file)
+    if (!handle->file)
         HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "(hdfs) could not open")
 
     ret_value = handle;
 
 done:
-    if(ret_value == NULL && handle != NULL) {
+    if (ret_value == NULL && handle != NULL) {
         /* error; clean up */
         HDassert(handle->magic == HDFS_HDFST_MAGIC);
         handle->magic++;
-        if(handle->file != NULL)
-            if(FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
+        if (handle->file != NULL)
+            if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
                 HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close hdfs file handle")
-        if(handle->fileinfo != NULL)
+        if (handle->fileinfo != NULL)
             hdfsFreeFileInfo(handle->fileinfo, 1);
-        if(handle->filesystem != NULL)
-            if(FAIL == (hdfsDisconnect(handle->filesystem)))
+        if (handle->filesystem != NULL)
+            if (FAIL == (hdfsDisconnect(handle->filesystem)))
                 HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to disconnect from hdfs")
         H5MM_xfree(handle);
     }
@@ -517,7 +503,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_handle_open() */
 
-
 /*--------------------------------------------------------------------------
  * Function:   H5FD__hdfs_handle_close
  *
@@ -543,19 +528,19 @@ H5FD__hdfs_handle_close(hdfs_t *handle)
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif
 
-    if(handle == NULL)
+    if (handle == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle cannot be null")
-    if(handle->magic != HDFS_HDFST_MAGIC)
+    if (handle->magic != HDFS_HDFST_MAGIC)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle has invalid magic")
 
     handle->magic++;
-    if(handle->file != NULL)
-        if(FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
+    if (handle->file != NULL)
+        if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
             HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close hdfs file handle")
-    if(handle->fileinfo != NULL)
+    if (handle->fileinfo != NULL)
         hdfsFreeFileInfo(handle->fileinfo, 1);
-    if(handle->filesystem != NULL)
-        if(FAIL == (hdfsDisconnect(handle->filesystem)))
+    if (handle->filesystem != NULL)
+        if (FAIL == (hdfsDisconnect(handle->filesystem)))
             HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to disconnect hdfs file system")
 
     H5MM_xfree(handle);
@@ -564,7 +549,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_handle_close() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__hdfs_validate_config()
  *
@@ -586,7 +570,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t * fa)
+H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t *fa)
 {
     herr_t ret_value = SUCCEED;
 
@@ -594,18 +578,17 @@ H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t * fa)
 
     HDassert(fa != NULL);
 
-    if(fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION)
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Unknown H5FD_hdfs_fapl_t version");
-    if(fa->namenode_port > 65535)
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
-    if(fa->namenode_port < 0)
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
+    if (fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Unknown H5FD_hdfs_fapl_t version");
+    if (fa->namenode_port > 65535)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
+    if (fa->namenode_port < 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_validate_config() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pset_fapl_hdfs
  *
@@ -637,9 +620,9 @@ H5Pset_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa)
 #endif
 
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
-    if(plist == NULL)
+    if (plist == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
-    if(FAIL == H5FD__hdfs_validate_config(fa))
+    if (FAIL == H5FD__hdfs_validate_config(fa))
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid hdfs config")
 
     ret_value = H5P_set_driver(plist, H5FD_HDFS, (void *)fa);
@@ -648,7 +631,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* H5Pset_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pget_fapl_hdfs
  *
@@ -668,7 +650,7 @@ herr_t
 H5Pget_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa_out)
 {
     const H5FD_hdfs_fapl_t *fa        = NULL;
-    H5P_genplist_t         *plist     = NULL;
+    H5P_genplist_t *        plist     = NULL;
     herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
@@ -678,16 +660,16 @@ H5Pget_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa_out)
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif
 
-    if(fa_out == NULL)
+    if (fa_out == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "fa_out is NULL")
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
-    if(plist == NULL)
+    if (plist == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
-    if(H5FD_HDFS != H5P_peek_driver(plist))
+    if (H5FD_HDFS != H5P_peek_driver(plist))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver")
 
     fa = (const H5FD_hdfs_fapl_t *)H5P_peek_driver_info(plist);
-    if(fa == NULL)
+    if (fa == NULL)
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info")
 
     /* Copy the hdfs fapl data out */
@@ -697,7 +679,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* H5Pget_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__hdfs_fapl_get
  *
@@ -716,14 +697,14 @@ done:
 static void *
 H5FD__hdfs_fapl_get(H5FD_t *_file)
 {
-    H5FD_hdfs_t      *file      = (H5FD_hdfs_t*)_file;
+    H5FD_hdfs_t *     file      = (H5FD_hdfs_t *)_file;
     H5FD_hdfs_fapl_t *fa        = NULL;
-    void             *ret_value = NULL;
+    void *            ret_value = NULL;
 
     FUNC_ENTER_STATIC
 
     fa = (H5FD_hdfs_fapl_t *)H5MM_calloc(sizeof(H5FD_hdfs_fapl_t));
-    if(fa == NULL)
+    if (fa == NULL)
         HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "memory allocation failed")
 
     /* Copy the fields of the structure */
@@ -732,13 +713,12 @@ H5FD__hdfs_fapl_get(H5FD_t *_file)
     ret_value = fa;
 
 done:
-    if(ret_value == NULL && fa != NULL)
+    if (ret_value == NULL && fa != NULL)
         H5MM_xfree(fa); /* clean up on error */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_fapl_get() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__hdfs_fapl_copy
  *
@@ -756,27 +736,26 @@ done:
 static void *
 H5FD__hdfs_fapl_copy(const void *_old_fa)
 {
-    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t*)_old_fa;
-    H5FD_hdfs_fapl_t       *new_fa    = NULL;
-    void                   *ret_value = NULL;
+    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t *)_old_fa;
+    H5FD_hdfs_fapl_t *      new_fa    = NULL;
+    void *                  ret_value = NULL;
 
     FUNC_ENTER_STATIC
 
     new_fa = (H5FD_hdfs_fapl_t *)H5MM_malloc(sizeof(H5FD_hdfs_fapl_t));
-    if(new_fa == NULL)
+    if (new_fa == NULL)
         HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "memory allocation failed")
 
     HDmemcpy(new_fa, old_fa, sizeof(H5FD_hdfs_fapl_t));
     ret_value = new_fa;
 
 done:
-    if(ret_value == NULL && new_fa != NULL)
+    if (ret_value == NULL && new_fa != NULL)
         H5MM_xfree(new_fa); /* clean up on error */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_fapl_copy() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__hdfs_fapl_free
  *
@@ -792,7 +771,7 @@ done:
 static herr_t
 H5FD__hdfs_fapl_free(void *_fa)
 {
-    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t*)_fa;
+    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t *)_fa;
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -803,7 +782,6 @@ H5FD__hdfs_fapl_free(void *_fa)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5FD__hdfs_fapl_free() */
 
-
 #if HDFS_STATS
 /*----------------------------------------------------------------------------
  *
@@ -838,14 +816,14 @@ hdfs__reset_stats(H5FD_hdfs_t *file)
     HDprintf("hdfs__reset_stats() called\n");
 #endif
 
-    if(file == NULL)
+    if (file == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file was null")
 
-    for(i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
-        file->raw[i].bytes  = 0;
-        file->raw[i].count  = 0;
-        file->raw[i].min    = (unsigned long long)HDFS_STATS_STARTING_MIN;
-        file->raw[i].max    = 0;
+    for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
+        file->raw[i].bytes = 0;
+        file->raw[i].count = 0;
+        file->raw[i].min   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+        file->raw[i].max   = 0;
 
         file->meta[i].bytes = 0;
         file->meta[i].count = 0;
@@ -859,7 +837,6 @@ done:
 } /* hdfs__reset_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_open()
@@ -886,10 +863,10 @@ done:
 static H5FD_t *
 H5FD__hdfs_open(const char *path, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    H5FD_t           *ret_value = NULL;
-    H5FD_hdfs_t      *file      = NULL;
-    hdfs_t           *handle    = NULL;
-    H5FD_hdfs_fapl_t  fa;
+    H5FD_t *         ret_value = NULL;
+    H5FD_hdfs_t *    file      = NULL;
+    hdfs_t *         handle    = NULL;
+    H5FD_hdfs_fapl_t fa;
 
     FUNC_ENTER_STATIC
 
@@ -901,53 +878,52 @@ H5FD__hdfs_open(const char *path, unsigned flags, hid_t fapl_id, haddr_t maxaddr
     HDcompile_assert(sizeof(HDoff_t) >= sizeof(size_t));
 
     /* Check arguments */
-    if(!path || !*path)
+    if (!path || !*path)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
-    if(0 == maxaddr || HADDR_UNDEF == maxaddr)
+    if (0 == maxaddr || HADDR_UNDEF == maxaddr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr")
-    if(ADDR_OVERFLOW(maxaddr))
+    if (ADDR_OVERFLOW(maxaddr))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr")
-    if(flags != H5F_ACC_RDONLY)
+    if (flags != H5F_ACC_RDONLY)
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL, "only Read-Only access allowed")
-    if(fapl_id == H5P_DEFAULT || fapl_id == H5P_FILE_ACCESS_DEFAULT)
+    if (fapl_id == H5P_DEFAULT || fapl_id == H5P_FILE_ACCESS_DEFAULT)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "fapl cannot be H5P_DEFAULT")
-    if(FAIL == H5Pget_fapl_hdfs(fapl_id, &fa))
+    if (FAIL == H5Pget_fapl_hdfs(fapl_id, &fa))
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't get property list")
 
-    handle = H5FD__hdfs_handle_open(path, fa.namenode_name, fa.namenode_port,
-            fa.user_name, fa.kerberos_ticket_cache, fa.stream_buffer_size);
-    if(handle == NULL)
+    handle = H5FD__hdfs_handle_open(path, fa.namenode_name, fa.namenode_port, fa.user_name,
+                                    fa.kerberos_ticket_cache, fa.stream_buffer_size);
+    if (handle == NULL)
         HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "could not open")
 
     HDassert(handle->magic == HDFS_HDFST_MAGIC);
 
     /* Create new file struct */
     file = H5FL_CALLOC(H5FD_hdfs_t);
-    if(file == NULL)
+    if (file == NULL)
         HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate file struct")
     file->hdfs_handle = handle;
     HDmemcpy(&(file->fa), &fa, sizeof(H5FD_hdfs_fapl_t));
 
 #if HDFS_STATS
-    if(FAIL == hdfs__reset_stats(file))
+    if (FAIL == hdfs__reset_stats(file))
         HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, NULL, "unable to reset file statistics")
 #endif /* HDFS_STATS */
 
-    ret_value = (H5FD_t*)file;
+    ret_value = (H5FD_t *)file;
 
 done:
-    if(ret_value == NULL) {
-        if(handle != NULL)
-            if(FAIL == H5FD__hdfs_handle_close(handle))
+    if (ret_value == NULL) {
+        if (handle != NULL)
+            if (FAIL == H5FD__hdfs_handle_close(handle))
                 HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close HDFS file handle")
-        if(file != NULL)
+        if (file != NULL)
             file = H5FL_FREE(H5FD_hdfs_t, file);
     } /* end if null return value (error) */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_open() */
 
-
 #if HDFS_STATS
 
 /*----------------------------------------------------------------------------
@@ -1008,70 +984,70 @@ static herr_t
 hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 {
     herr_t             ret_value    = SUCCEED;
-    parsed_url_t      *purl         = NULL;
+    parsed_url_t *     purl         = NULL;
     unsigned           i            = 0;
     unsigned long      count_meta   = 0;
     unsigned long      count_raw    = 0;
     double             average_meta = 0.0;
     double             average_raw  = 0.0;
-    unsigned long long min_meta  = (unsigned long long)HDFS_STATS_STARTING_MIN;
-    unsigned long long min_raw   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_meta     = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_raw      = (unsigned long long)HDFS_STATS_STARTING_MIN;
     unsigned long long max_meta     = 0;
     unsigned long long max_raw      = 0;
     unsigned long long bytes_raw    = 0;
     unsigned long long bytes_meta   = 0;
     double             re_dub       = 0.0; /* re-usable double variable */
     unsigned           suffix_i     = 0;
-    const char         suffixes[]   = { ' ', 'K', 'M', 'G', 'T', 'P' };
+    const char         suffixes[]   = {' ', 'K', 'M', 'G', 'T', 'P'};
 
     FUNC_ENTER_STATIC
 
-    if(stream == NULL)
+    if (stream == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file stream cannot be null")
-    if(file == NULL)
+    if (file == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file cannot be null")
-    if(file->hdfs_handle == NULL)
+    if (file->hdfs_handle == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle cannot be null")
-    if(file->hdfs_handle->magic != HDFS_HDFST_MAGIC)
+    if (file->hdfs_handle->magic != HDFS_HDFST_MAGIC)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle has invalid magic")
 
     /*******************
      * AGGREGATE STATS *
      *******************/
 
-    for(i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
+    for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
         const hdfs_statsbin *r = &file->raw[i];
         const hdfs_statsbin *m = &file->meta[i];
 
-        if(m->min < min_meta)
+        if (m->min < min_meta)
             min_meta = m->min;
-        if(r->min < min_raw)
-            min_raw  = r->min;
-        if(m->max > max_meta)
+        if (r->min < min_raw)
+            min_raw = r->min;
+        if (m->max > max_meta)
             max_meta = m->max;
-        if(r->max > max_raw)
-            max_raw  = r->max;
+        if (r->max > max_raw)
+            max_raw = r->max;
 
-        count_raw  += r->count;
+        count_raw += r->count;
         count_meta += m->count;
-        bytes_raw  += r->bytes;
+        bytes_raw += r->bytes;
         bytes_meta += m->bytes;
     }
-    if(count_raw  > 0)
-        average_raw  = (double)bytes_raw / (double)count_raw;
-    if(count_meta > 0)
+    if (count_raw > 0)
+        average_raw = (double)bytes_raw / (double)count_raw;
+    if (count_meta > 0)
         average_meta = (double)bytes_meta / (double)count_meta;
 
     /******************
      * PRINT OVERVIEW *
      ******************/
 
-    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n",
-              count_raw + count_meta, count_meta, count_raw);
-    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n",
-              bytes_raw + bytes_meta, bytes_meta, bytes_raw);
+    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n", count_raw + count_meta, count_meta,
+              count_raw);
+    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n", bytes_raw + bytes_meta, bytes_meta,
+              bytes_raw);
 
-    if(count_raw + count_meta == 0)
+    if (count_raw + count_meta == 0)
         goto done;
 
     /*************************
@@ -1080,21 +1056,21 @@ hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 
     HDfprintf(stream, "SIZES     meta      raw\n");
     HDfprintf(stream, "  min ");
-    if(count_meta == 0)
+    if (count_meta == 0)
         HDfprintf(stream, "   0.000  ");
     else {
         re_dub = (double)min_meta;
-        for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
     }
 
-    if(count_raw == 0)
+    if (count_raw == 0)
         HDfprintf(stream, "   0.000 \n");
     else {
         re_dub = (double)min_raw;
-        for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
@@ -1102,26 +1078,26 @@ hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 
     HDfprintf(stream, "  avg ");
     re_dub = (double)average_meta;
-    for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
 
     re_dub = (double)average_raw;
-    for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
 
     HDfprintf(stream, "  max ");
     re_dub = (double)max_meta;
-    for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
 
     re_dub = (double)max_raw;
-    for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
@@ -1130,12 +1106,10 @@ hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
      * PRINT INDIVIDUAL BIN STATS *
      ******************************/
 
-    HDfprintf(stream,
-        "BINS             # of reads      total bytes         average size\n");
-    HDfprintf(stream,
-        "    up-to      meta     raw     meta      raw       meta      raw\n");
+    HDfprintf(stream, "BINS             # of reads      total bytes         average size\n");
+    HDfprintf(stream, "    up-to      meta     raw     meta      raw       meta      raw\n");
 
-    for(i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
+    for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
         const hdfs_statsbin *m;
         const hdfs_statsbin *r;
         unsigned long long   range_end = 0;
@@ -1150,59 +1124,57 @@ hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 
         m = &file->meta[i];
         r = &file->raw[i];
-        if(r->count == 0 && m->count == 0)
+        if (r->count == 0 && m->count == 0)
             continue;
 
         range_end = hdfs_stats_boundaries[i];
 
-        if(i == HDFS_STATS_BIN_COUNT) {
-            range_end = hdfs_stats_boundaries[i-1];
+        if (i == HDFS_STATS_BIN_COUNT) {
+            range_end = hdfs_stats_boundaries[i - 1];
             HDfprintf(stream, ">");
         }
         else
             HDfprintf(stream, " ");
 
         bm_val = (double)m->bytes;
-        for(suffix_i = 0; bm_val >= 1024.0; suffix_i++)
+        for (suffix_i = 0; bm_val >= 1024.0; suffix_i++)
             bm_val /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         bm_suffix = suffixes[suffix_i];
 
         br_val = (double)r->bytes;
-        for(suffix_i = 0; br_val >= 1024.0; suffix_i++)
+        for (suffix_i = 0; br_val >= 1024.0; suffix_i++)
             br_val /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         br_suffix = suffixes[suffix_i];
 
-        if(m->count > 0)
+        if (m->count > 0)
             am_val = (double)(m->bytes) / (double)(m->count);
-        for(suffix_i = 0; am_val >= 1024.0; suffix_i++)
+        for (suffix_i = 0; am_val >= 1024.0; suffix_i++)
             am_val /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         am_suffix = suffixes[suffix_i];
 
-        if(r->count > 0)
+        if (r->count > 0)
             ar_val = (double)(r->bytes) / (double)(r->count);
-        for(suffix_i = 0; ar_val >= 1024.0; suffix_i++)
+        for (suffix_i = 0; ar_val >= 1024.0; suffix_i++)
             ar_val /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
         ar_suffix = suffixes[suffix_i];
 
         re_dub = (double)range_end;
-        for(suffix_i = 0; re_dub >= 1024.0; suffix_i++)
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
         HDassert(suffix_i < sizeof(suffixes));
 
-        HDfprintf(
-                stream,
-                " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n",
-                re_dub, suffixes[suffix_i], /* bin ceiling      */
-                m->count,                   /* metadata reads   */
-                r->count,                   /* rawdata reads    */
-                bm_val, bm_suffix,          /* metadata bytes   */
-                br_val, br_suffix,          /* rawdata bytes    */
-                am_val, am_suffix,          /* metadata average */
-                ar_val, ar_suffix);         /* rawdata average  */
+        HDfprintf(stream, " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n", re_dub,
+                  suffixes[suffix_i], /* bin ceiling      */
+                  m->count,           /* metadata reads   */
+                  r->count,           /* rawdata reads    */
+                  bm_val, bm_suffix,  /* metadata bytes   */
+                  br_val, br_suffix,  /* rawdata bytes    */
+                  am_val, am_suffix,  /* metadata average */
+                  ar_val, ar_suffix); /* rawdata average  */
         HDfflush(stream);
     }
 
@@ -1211,7 +1183,6 @@ done:
 } /* hdfs__fprint_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_close()
@@ -1247,13 +1218,13 @@ H5FD__hdfs_close(H5FD_t *_file)
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
 
     /* Close the underlying request handle */
-    if(file->hdfs_handle != NULL)
-        if(FAIL == H5FD__hdfs_handle_close(file->hdfs_handle))
+    if (file->hdfs_handle != NULL)
+        if (FAIL == H5FD__hdfs_handle_close(file->hdfs_handle))
             HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close HDFS file handle")
 
 #if HDFS_STATS
     /* TODO: mechanism to re-target stats printout */
-    if(FAIL == hdfs__fprint_stats(stdout, file))
+    if (FAIL == hdfs__fprint_stats(stdout, file))
         HGOTO_ERROR(H5E_INTERNAL, H5E_ERROR, FAIL, "problem while writing file statistics")
 #endif /* HDFS_STATS */
 
@@ -1264,7 +1235,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__hdfs_close() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_cmp()
@@ -1289,8 +1259,8 @@ H5FD__hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
     int                ret_value = 0;
     const H5FD_hdfs_t *f1        = (const H5FD_hdfs_t *)_f1;
     const H5FD_hdfs_t *f2        = (const H5FD_hdfs_t *)_f2;
-    hdfsFileInfo      *finfo1    = NULL;
-    hdfsFileInfo      *finfo2    = NULL;
+    hdfsFileInfo *     finfo1    = NULL;
+    hdfsFileInfo *     finfo2    = NULL;
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -1308,22 +1278,41 @@ H5FD__hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
     HDassert(finfo1 != NULL);
     HDassert(finfo2 != NULL);
 
-    if(finfo1->mKind        != finfo2->mKind)        { HGOTO_DONE(-1); }
-    if(finfo1->mName        != finfo2->mName)        { HGOTO_DONE(-1); }
-    if(finfo1->mLastMod     != finfo2->mLastMod)     { HGOTO_DONE(-1); }
-    if(finfo1->mSize        != finfo2->mSize)        { HGOTO_DONE(-1); }
-    if(finfo1->mReplication != finfo2->mReplication) { HGOTO_DONE(-1); }
-    if(finfo1->mBlockSize   != finfo2->mBlockSize)   { HGOTO_DONE(-1); }
-    if(HDstrcmp(finfo1->mOwner, finfo2->mOwner))     { HGOTO_DONE(-1); }
-    if(HDstrcmp(finfo1->mGroup, finfo2->mGroup))     { HGOTO_DONE(-1); }
-    if(finfo1->mPermissions != finfo2->mPermissions) { HGOTO_DONE(-1); }
-    if(finfo1->mLastAccess  != finfo2->mLastAccess)  { HGOTO_DONE(-1); }
+    if (finfo1->mKind != finfo2->mKind) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mName != finfo2->mName) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastMod != finfo2->mLastMod) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mSize != finfo2->mSize) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mReplication != finfo2->mReplication) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mBlockSize != finfo2->mBlockSize) {
+        HGOTO_DONE(-1);
+    }
+    if (HDstrcmp(finfo1->mOwner, finfo2->mOwner)) {
+        HGOTO_DONE(-1);
+    }
+    if (HDstrcmp(finfo1->mGroup, finfo2->mGroup)) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mPermissions != finfo2->mPermissions) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastAccess != finfo2->mLastAccess) {
+        HGOTO_DONE(-1);
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_cmp() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__hdfs_query
  *
@@ -1352,7 +1341,7 @@ H5FD__hdfs_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif
 
-    if(flags) {
+    if (flags) {
         *flags = 0;
         *flags |= H5FD_FEAT_DATA_SIEVE;
     }
@@ -1360,7 +1349,6 @@ H5FD__hdfs_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5FD__hdfs_query() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_get_eoa()
@@ -1394,7 +1382,6 @@ H5FD__hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
     FUNC_LEAVE_NOAPI(file->eoa)
 } /* end H5FD__hdfs_get_eoa() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_set_eoa()
@@ -1428,7 +1415,6 @@ H5FD__hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5FD__hdfs_set_eoa() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_get_eof()
@@ -1461,10 +1447,9 @@ H5FD__hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
     HDassert(file->hdfs_handle != NULL);
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
 
-    FUNC_LEAVE_NOAPI((size_t) file->hdfs_handle->fileinfo->mSize)
+    FUNC_LEAVE_NOAPI((size_t)file->hdfs_handle->fileinfo->mSize)
 } /* end H5FD__hdfs_get_eof() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_get_handle()
@@ -1494,7 +1479,7 @@ H5FD__hdfs_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_hand
     HDfprintf(stdout, "called %s.\n", FUNC);
 #endif /* HDFS_DEBUG */
 
-    if(!file_handle)
+    if (!file_handle)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
 
     *file_handle = file->hdfs_handle;
@@ -1503,7 +1488,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__hdfs_get_handle() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_read()
@@ -1527,8 +1511,8 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type,
-    hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, size_t size, void *buf)
+H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
+                size_t size, void *buf)
 {
     herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
@@ -1550,34 +1534,32 @@ H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type,
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
     HDassert(buf != NULL);
 
-    filesize = (size_t) file->hdfs_handle->fileinfo->mSize;
+    filesize = (size_t)file->hdfs_handle->fileinfo->mSize;
 
-    if((addr > filesize) || ((addr + size) > filesize))
+    if ((addr > filesize) || ((addr + size) > filesize))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "range exceeds file address")
 
-    if(FAIL == hdfsPread(file->hdfs_handle->filesystem, file->hdfs_handle->file,
-            (tOffset)addr, buf, (tSize)size))
+    if (FAIL ==
+        hdfsPread(file->hdfs_handle->filesystem, file->hdfs_handle->file, (tOffset)addr, buf, (tSize)size))
         HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "unable to execute read")
 
 #if HDFS_STATS
 
     /* Find which "bin" this read fits in. Can be "overflow" bin. */
-    for(bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++)
-        if((unsigned long long)size < hdfs_stats_boundaries[bin_i])
+    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++)
+        if ((unsigned long long)size < hdfs_stats_boundaries[bin_i])
             break;
-    bin = (type == H5FD_MEM_DRAW)
-        ? &file->raw[bin_i]
-        : &file->meta[bin_i];
+    bin = (type == H5FD_MEM_DRAW) ? &file->raw[bin_i] : &file->meta[bin_i];
 
     /* Store collected stats in appropriate bin */
-    if(bin->count == 0) {
+    if (bin->count == 0) {
         bin->min = size;
         bin->max = size;
     }
     else {
-        if(size < bin->min)
+        if (size < bin->min)
             bin->min = size;
-        if(size > bin->max)
+        if (size > bin->max)
             bin->max = size;
     }
     bin->count++;
@@ -1589,7 +1571,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__hdfs_read() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_write()
@@ -1609,9 +1590,8 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__hdfs_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED  type,
-    hid_t H5_ATTR_UNUSED  dxpl_id, haddr_t H5_ATTR_UNUSED  addr, size_t H5_ATTR_UNUSED  size,
-    const void H5_ATTR_UNUSED *buf)
+H5FD__hdfs_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id,
+                 haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, const void H5_ATTR_UNUSED *buf)
 {
     herr_t ret_value = FAIL;
 
@@ -1627,7 +1607,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__hdfs_write() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_truncate()
@@ -1650,7 +1629,7 @@ done:
  */
 static herr_t
 H5FD__hdfs_truncate(H5FD_t H5_ATTR_UNUSED *_file, hid_t H5_ATTR_UNUSED dxpl_id,
-    hbool_t H5_ATTR_UNUSED closing)
+                    hbool_t H5_ATTR_UNUSED closing)
 {
     herr_t ret_value = SUCCEED;
 
@@ -1666,7 +1645,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__hdfs_truncate() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_lock()
@@ -1689,16 +1667,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__hdfs_lock(
-        H5FD_t  H5_ATTR_UNUSED *_file,
-        hbool_t H5_ATTR_UNUSED  rw)
+H5FD__hdfs_lock(H5FD_t H5_ATTR_UNUSED *_file, hbool_t H5_ATTR_UNUSED rw)
 {
     FUNC_ENTER_STATIC_NOERR
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD__hdfs_lock() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD__hdfs_unlock()
@@ -1725,4 +1700,3 @@ H5FD__hdfs_unlock(H5FD_t H5_ATTR_UNUSED *_file)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD__hdfs_unlock() */
 #endif /* H5_HAVE_LIBHDFS */
-