FileType_HDF5.f90

!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
!                          Futility Development Group                          !
!                             All rights reserved.                             !
!                                                                              !
! Futility is a jointly-maintained, open-source project between the University !
! of Michigan and Oak Ridge National Laboratory.  The copyright and license    !
! can be found in LICENSE.txt in the head directory of this repository.        !
!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
!> @brief Utility module for I/O defines the HDF5 file type object.
!>
!> This type is an extension of the base file type implemented in FileType_Base.
!> It contains specific routines for interrogating an HDF5-format binary file
!> and for writing to and reading from records in an HDF5 file. Since the module
!> relies of the HDF5 library to be present, the entire module is disabled and
!> not compiled if the build system does not have HDF5 support enabled.
!>
!> There are actually two versions of the HDF library, a serial implementation
!> and a parallel implementation. The latter relies on MPI and has separate
!> subroutine calls, so there will need to be preprocessor directives switching
!> between the two depending on which library is present.
!>
!> It is important to note that the read and write routines are typed to use
!> fixed precision (for instance SSK and SDK instead of SRK). This is important
!> because we need to use the supported types of the HDF5 library and file
!> format.
!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
MODULE FileType_HDF5
#include "Futility_DBC.h"
USE Futility_DBC
USE ISO_FORTRAN_ENV
USE ISO_C_BINDING
#ifdef FUTILITY_HAVE_HDF5
USE HDF5
#endif
USE IntrType
USE Strings
USE ExceptionHandler
USE IO_Strings
USE ParameterLists
USE ParallelEnv
USE FileType_Base

IMPLICIT NONE
PRIVATE

#ifdef FUTILITY_HAVE_HDF5
INTEGER,PRIVATE :: error
#endif

!> Name of the module
CHARACTER(LEN=*),PARAMETER :: modName='FileType_HDF5'

!> Set maximum string length
INTEGER(SIK),PARAMETER :: MAXSTRLEN=1024

!> This type extends the base file type, and adds support for writing to and
!List of Public Members
PUBLIC :: HDF5FileType
PUBLIC :: HDF5FilePtrArrayType
PUBLIC :: HDF5Open
PUBLIC :: HDF5Close
PUBLIC :: HDF5Quiet

!> reading from HDF5 binary files. As implemented, there are three modes for
!> accessing a file can be opened as: 'read' and 'write' and 'new'. Read mode
!> opens an already extant HDF5 file and allows the client code to interrogate
!> that file and extract data without permissions to alter the file. Write
!> mode opens an extant HDF5 file and allows the client code to alter its
!> contents. New mode overwrites any file by the same name and starts from
!> scratch.
TYPE,EXTENDS(BaseFileType) :: HDF5FileType
  !> Initialization status
  LOGICAL(SBK) :: isInit=.FALSE.
  !> Whether or not the file uses compression for writing
  LOGICAL(SBK) :: hasCompression=.FALSE.
  !> Option for gzip compression -1 (no filter) or [0-9].
  !> these options are defined by HDF5.
  !> https://support.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetDeflate
  INTEGER(SIK),PRIVATE :: zlibOpt=-1
  !> The 'new' status of a file
  LOGICAL(SBK),PRIVATE :: newstat=.FALSE.
  !> Full path to the file
  TYPE(StringType) :: fullname
  !> The unit number of the file
  INTEGER(SIK),PRIVATE :: unitno=-1
  !> Parallel environment for MPI I/O
  TYPE(MPI_EnvType),POINTER  :: pe => NULL()
  !> When .TRUE., file data can be overwritten
  LOGICAL(SBK),PRIVATE :: overwriteStat=.FALSE.

#ifdef FUTILITY_HAVE_HDF5
  !> File id assigned by the HDF5 library when file is opened
  INTEGER(HID_T) :: file_id=0
#endif

  CONTAINS
    !> @copybrief FileType_HDF5::init_HDF5FileType
    !> @copydetails FileType_HDF5::init_HDF5FileType
    PROCEDURE,PASS :: init => init_HDF5FileType
    !> @copybrief FileType_HDF5::clear_HDF5FileType
    !> @copydetails FileType_HDF5::clear_HDF5FileType
    PROCEDURE,PASS :: clear => clear_HDF5FileType
    !> @copybrief FileType_HDF5::setOverwriteStat_file
    !> @copydetails FileType_HDF5::setOverwriteStat_file
    PROCEDURE,PASS :: setOverwriteStat => setOverwriteStat_file
    !> @copybrief FileType_HDF5::open_HDF5FileType
    !> @copydetails FileType_HDF5::open_HDF5FileType
    PROCEDURE,PASS :: fopen => open_HDF5FileType
    !> @copybrief FileType_HDF5::close_HDF5FileType
    !> @copydetails FileType_HDF5::close_HDF5FileType
    PROCEDURE,PASS :: fclose => close_HDF5FileType
    !> @copybrief FileType_HDF5::delete_HDF5FileType
    !> @copydetails FileType_HDF5::delete_HDF5FileType
    PROCEDURE,PASS :: fdelete => delete_HDF5FileType
    !> @copybrief FileType_HDF5::getUnitNo_HFD5FileType
    !> @copydetails FileType_HDF5::getUnitNo_HDF5FileType
    PROCEDURE,PASS :: getUnitNo => getUnitNo_HDF5FileType
    !> @copybrief FileType_HDF5::isNew_HDF5FileType
    !> @copydetails FileType_HDF5::isNew_HDF5FileType
    PROCEDURE,PASS :: isNew => isNew_HDF5FileType
    !> @copybrief FileType_HDF5::setNewStat_HDF5FileType
    !> @copydetails FileType_HDF5::setNewStat_HDF5FileType
    PROCEDURE,PASS,PRIVATE :: setNewStat => setNewStat_HDF5FileType
    !> @copybrief FileType_HDF5::ls_HDF5FileType
    !> @copydetails FileType_HDF5::ls_HDF5FileType
    PROCEDURE,PASS :: ls => ls_HDF5FileType
    !> @copybrief FileType_HDF5::mkdir_HDF5FileType
    !> @copydetails FileType_HDF5::mkdir_HDF5FileType
    PROCEDURE,PASS :: mkdir => mkdir_HDF5FileType
    !> @copybrief FileType_HDF5::mkalldir_HDF5FileType
    !> @copydetails FileType_HDF5::mkalldir_HDF5FileType
    PROCEDURE,PASS :: mkalldir => mkalldir_HDF5FileType
    !> @copybrief FileType_HDF5::ngrp_HDF5FileType
    !> @copydetails FileType_HDF5::ngrp_HDF5FileType
    PROCEDURE,PASS :: ngrp => ngrp_HDF5FileType
    !> @copybrief FileType_HDF5::isgrp_HDF5FileType
    !> @copydetails FileType_HDF5::isgrp_HDF5FileType
    PROCEDURE,PASS :: isGroup => isgrp_HDF5FileType
    !> @copybrief FileType_HDF5::pathexists_HDF5FileType
    !> @copydetails FileType_HDF5::pathexists_HDF5FileType
    PROCEDURE,PASS :: pathExists => pathexists_HDF5FileType
    !> @copybrief FileType_HDF5::createHardLink_HDF5FileType
    !> @copydetails FileType_HDF5::createHardLink_HDF5FileType
    PROCEDURE,PASS :: createHardLink => createHardLink_HDF5FileType
    !> @copybrief FileType_HDF5::getChunkSize_HDF5FileType
    !> @copydetails FileType_HDF5::getChunkSize_HDF5FileType
    PROCEDURE,PASS :: getChunkSize => getChunkSize_HDF5FileType
    !> @copybrief FileType_HDF5::isCompressed_HDF5FileType
    !> @copydetails FileType_HDF5::isCompressed_HDF5FileType
    PROCEDURE,PASS :: isCompressed => isCompressed_HDF5FileType
    !> @copybrief FileType_HDF5::write_d0
    !> @copydoc FileType_HDF5::write_d0
    PROCEDURE,PASS,PRIVATE :: write_d0
    !> @copybrief FileType_HDF5::write_d1
    !> @copydoc FileType_HDF5::write_d1
    PROCEDURE,PASS,PRIVATE :: write_d1
    !> @copybrief FileType_HDF5::write_d2
    !> @copydoc FileType_HDF5::write_d2
    PROCEDURE,PASS,PRIVATE :: write_d2
    !> @copybrief FileType_HDF5::write_d3
    !> @copydoc FileType_HDF5::write_d3
    PROCEDURE,PASS,PRIVATE :: write_d3
    !> @copybrief FileType_HDF5::write_d4
    !> @copydoc FileType_HDF5::write_d4
    PROCEDURE,PASS,PRIVATE :: write_d4
    !> @copybrief FileType_HDF5::write_d5
    !> @copydoc FileType_HDF5::write_d5
    PROCEDURE,PASS,PRIVATE :: write_d5
    !> @copybrief FileType_HDF5::write_d6
    !> @copydoc FileType_HDF5::write_d6
    PROCEDURE,PASS,PRIVATE :: write_d6
    !> @copybrief FileType_HDF5::write_d7
    !> @copydoc FileType_HDF5::write_d7
    PROCEDURE,PASS,PRIVATE :: write_d7
    !> @copybrief FileType_HDF5::write_s0
    !> @copydoc FileType_HDF5::write_s0
    PROCEDURE,PASS,PRIVATE :: write_s0
    !> @copybrief FileType_HDF5::write_s1
    !> @copydoc FileType_HDF5::write_s1
    PROCEDURE,PASS,PRIVATE :: write_s1
    !> @copybrief FileType_HDF5::write_s2
    !> @copydoc FileType_HDF5::write_s2
    PROCEDURE,PASS,PRIVATE :: write_s2
    !> @copybrief FileType_HDF5::write_s3
    !> @copydoc FileType_HDF5::write_s3
    PROCEDURE,PASS,PRIVATE :: write_s3
    !> @copybrief FileType_HDF5::write_s4
    !> @copydoc FileType_HDF5::write_s4
    PROCEDURE,PASS,PRIVATE :: write_s4
    !> @copybrief FileType_HDF5::write_s5
    !> @copydoc FileType_HDF5::write_s5
    PROCEDURE,PASS,PRIVATE :: write_s5
    !> @copybrief FileType_HDF5::write_s6
    !> @copydoc FileType_HDF5::write_s6
    PROCEDURE,PASS,PRIVATE :: write_s6
    !> @copybrief FileType_HDF5::write_s7
    !> @copydoc FileType_HDF5::write_s7
    PROCEDURE,PASS,PRIVATE :: write_s7
    !> @copybrief FileType_HDF5::write_b0
    !> @copydoc FileType_HDF5::write_b0
    PROCEDURE,PASS,PRIVATE :: write_b0
    !> @copybrief FileType_HDF5::write_b1
    !> @copydoc FileType_HDF5::write_b1
    PROCEDURE,PASS,PRIVATE :: write_b1
    !> @copybrief FileType_HDF5::write_b2
    !> @copydoc FileType_HDF5::write_b2
    PROCEDURE,PASS,PRIVATE :: write_b2
    !> @copybrief FileType_HDF5::write_b3
    !> @copydoc FileType_HDF5::write_b3
    PROCEDURE,PASS,PRIVATE :: write_b3
    !> @copybrief FileType_HDF5::write_n0
    !> @copydoc FileType_HDF5::write_n0
    PROCEDURE,PASS,PRIVATE :: write_n0
    !> @copybrief FileType_HDF5::write_n1
    !> @copydoc FileType_HDF5::write_n1
    PROCEDURE,PASS,PRIVATE :: write_n1
    !> @copybrief FileType_HDF5::write_n2
    !> @copydoc FileType_HDF5::write_n2
    PROCEDURE,PASS,PRIVATE :: write_n2
    !> @copybrief FileType_HDF5::write_n3
    !> @copydoc FileType_HDF5::write_n3
    PROCEDURE,PASS,PRIVATE :: write_n3
    !> @copybrief FileType_HDF5::write_n4
    !> @copydoc FileType_HDF5::write_n4
    PROCEDURE,PASS,PRIVATE :: write_n4
    !> @copybrief FileType_HDF5::write_n5
    !> @copydoc FileType_HDF5::write_n5
    PROCEDURE,PASS,PRIVATE :: write_n5
    !> @copybrief FileType_HDF5::write_n6
    !> @copydoc FileType_HDF5::write_n6
    PROCEDURE,PASS,PRIVATE :: write_n6
    !> @copybrief FileType_HDF5::write_n7
    !> @copydoc FileType_HDF5::write_n7
    PROCEDURE,PASS,PRIVATE :: write_n7
    !> @copybrief FileType_HDF5::write_l0
    !> @copydoc FileType_HDF5::write_l0
    PROCEDURE,PASS,PRIVATE :: write_l0
    !> @copybrief FileType_HDF5::write_l1
    !> @copydoc FileType_HDF5::write_l1
    PROCEDURE,PASS,PRIVATE :: write_l1
    !> @copybrief FileType_HDF5::write_l2
    !> @copydoc FileType_HDF5::write_l2
    PROCEDURE,PASS,PRIVATE :: write_l2
    !> @copybrief FileType_HDF5::write_l3
    !> @copydoc FileType_HDF5::write_l3
    PROCEDURE,PASS,PRIVATE :: write_l3
    !> @copybrief FileType_HDF5::write_l4
    !> @copydoc FileType_HDF5::write_l4
    PROCEDURE,PASS,PRIVATE :: write_l4
    !> @copybrief FileType_HDF5::write_l5
    !> @copydoc FileType_HDF5::write_l5
    PROCEDURE,PASS,PRIVATE :: write_l5
    !> @copybrief FileType_HDF5::write_l6
    !> @copydoc FileType_HDF5::write_l6
    PROCEDURE,PASS,PRIVATE :: write_l6
    !> @copybrief FileType_HDF5::write_l7
    !> @copydoc FileType_HDF5::write_l7
    PROCEDURE,PASS,PRIVATE :: write_l7
    !> @copybrief FileType_HDF5::write_st0
    !> @copydoc FileType_HDF5::write_st0
    PROCEDURE,PASS,PRIVATE :: write_st0
    !> @copybrief FileType_HDF5::write_st1_helper
    !> @copydoc FileType_HDF5::write_st1_helper
    PROCEDURE,PASS,PRIVATE :: write_st1_helper
    !> @copybrief FileType_HDF5::write_st1
    !> @copydoc FileType_HDF5::write_st1
    PROCEDURE,PASS,PRIVATE :: write_st1
    !> @copybrief FileType_HDF5::write_st2_helper
    !> @copydoc FileType_HDF5::write_st2_helper
    PROCEDURE,PASS,PRIVATE :: write_st2_helper
    !> @copybrief FileType_HDF5::write_st2
    !> @copydoc FileType_HDF5::write_st2
    PROCEDURE,PASS,PRIVATE :: write_st2
    !> @copybrief FileType_HDF5::write_st3_helper
    !> @copydoc FileType_HDF5::write_st3_helper
    PROCEDURE,PASS,PRIVATE :: write_st3_helper
    !> @copybrief FileType_HDF5::write_st3
    !> @copydoc FileType_HDF5::write_st3
    PROCEDURE,PASS,PRIVATE :: write_st3
    !> @copybrief FileType_HDF5::write_c1
    !> @copydoc FileType_HDF5::write_c1
    PROCEDURE,PASS,PRIVATE :: write_c1
    !> @copybrief FileType_HDF5::write_pList
    !> @copydoc FileType_HDF5::write_pList
    PROCEDURE,PASS,PRIVATE :: write_pList
    !> Generic typebound interface for all @c write operations
    GENERIC :: fwrite => write_d0, write_d1, write_d2, write_d3, write_d4,   &
        write_d5, write_d6, write_d7, write_s0, write_s1, write_s2, write_s3, &
        write_s4, write_s5, write_s6, write_s7, write_b0, write_b1, write_b2, &
        write_b3, write_n0, write_n1, write_n2, write_n3, write_n4, write_n5, &
        write_n6, write_n7, write_st0, write_st1_helper, write_st1, write_st2_helper,  &
        write_st2, write_st3_helper, write_st3, write_l0, write_l1, write_l2, &
        write_l3, write_l4, write_l5, write_l6, write_l7,write_c1, write_pList
    !> @copybrief FileType_HDF5::read_d0
    !> @copydoc FileType_HDF5::read_d0
    PROCEDURE,PASS,PRIVATE :: read_d0
    !> @copybrief FileType_HDF5::read_d1
    !> @copydoc FileType_HDF5::read_d1
    PROCEDURE,PASS,PRIVATE :: read_d1
    !> @copybrief FileType_HDF5::read_d2
    !> @copydoc FileType_HDF5::read_d2
    PROCEDURE,PASS,PRIVATE :: read_d2
    !> @copybrief FileType_HDF5::read_d3
    !> @copydoc FileType_HDF5::read_d3
    PROCEDURE,PASS,PRIVATE :: read_d3
    !> @copybrief FileType_HDF5::read_d4
    !> @copydoc FileType_HDF5::read_d4
    PROCEDURE,PASS,PRIVATE :: read_d4
    !> @copybrief FileType_HDF5::read_d5
    !> @copydoc FileType_HDF5::read_d5
    PROCEDURE,PASS,PRIVATE :: read_d5
    !> @copybrief FileType_HDF5::read_d6
    !> @copydoc FileType_HDF5::read_d6
    PROCEDURE,PASS,PRIVATE :: read_d6
    !> @copybrief FileType_HDF5::read_d7
    !> @copydoc FileType_HDF5::read_d7
    PROCEDURE,PASS,PRIVATE :: read_d7
    !> @copybrief FileType_HDF5::read_dp4
    !> @copydoc FileType_HDF5::read_dp4
    PROCEDURE,PASS,PRIVATE :: read_dp4
    !> @copybrief FileType_HDF5::read_s0
    !> @copydoc FileType_HDF5::read_s0
    PROCEDURE,PASS,PRIVATE :: read_s0
    !> @copybrief FileType_HDF5::read_s1
    !> @copydoc FileType_HDF5::read_s1
    PROCEDURE,PASS,PRIVATE :: read_s1
    !> @copybrief FileType_HDF5::read_s2
    !> @copydoc FileType_HDF5::read_s2
    PROCEDURE,PASS,PRIVATE :: read_s2
    !> @copybrief FileType_HDF5::read_s3
    !> @copydoc FileType_HDF5::read_s3
    PROCEDURE,PASS,PRIVATE :: read_s3
    !> @copybrief FileType_HDF5::read_s4
    !> @copydoc FileType_HDF5::read_s4
    PROCEDURE,PASS,PRIVATE :: read_s4
    !> @copybrief FileType_HDF5::read_s5
    !> @copydoc FileType_HDF5::read_s5
    PROCEDURE,PASS,PRIVATE :: read_s5
    !> @copybrief FileType_HDF5::read_s6
    !> @copydoc FileType_HDF5::read_s6
    PROCEDURE,PASS,PRIVATE :: read_s6
    !> @copybrief FileType_HDF5::read_s7
    !> @copydoc FileType_HDF5::read_s7
    PROCEDURE,PASS,PRIVATE :: read_s7
    !> @copybrief FileType_HDF5::read_b0
    !> @copydoc FileType_HDF5::read_b0
    PROCEDURE,PASS,PRIVATE :: read_b0
    !> @copybrief FileType_HDF5::read_b1
    !> @copydoc FileType_HDF5::read_b1
    PROCEDURE,PASS,PRIVATE :: read_b1
    !> @copybrief FileType_HDF5::read_b2
    !> @copydoc FileType_HDF5::read_b2
    PROCEDURE,PASS,PRIVATE :: read_b2
    !> @copybrief FileType_HDF5::read_b3
    !> @copydoc FileType_HDF5::read_b3
    PROCEDURE,PASS,PRIVATE :: read_b3
    !> @copybrief FileType_HDF5::read_n0
    !> @copydoc FileType_HDF5::read_n0
    PROCEDURE,PASS,PRIVATE :: read_n0
    !> @copybrief FileType_HDF5::read_n1
    !> @copydoc FileType_HDF5::read_n1
    PROCEDURE,PASS,PRIVATE :: read_n1
    !> @copybrief FileType_HDF5::read_n2
    !> @copydoc FileType_HDF5::read_n2
    PROCEDURE,PASS,PRIVATE :: read_n2
    !> @copybrief FileType_HDF5::read_n3
    !> @copydoc FileType_HDF5::read_n3
    PROCEDURE,PASS,PRIVATE :: read_n3
    !> @copybrief FileType_HDF5::read_n4
    !> @copydoc FileType_HDF5::read_n4
    PROCEDURE,PASS,PRIVATE :: read_n4
    !> @copybrief FileType_HDF5::read_n5
    !> @copydoc FileType_HDF5::read_n5
    PROCEDURE,PASS,PRIVATE :: read_n5
    !> @copybrief FileType_HDF5::read_n6
    !> @copydoc FileType_HDF5::read_n6
    PROCEDURE,PASS,PRIVATE :: read_n6
    !> @copybrief FileType_HDF5::read_n7
    !> @copydoc FileType_HDF5::read_n7
    PROCEDURE,PASS,PRIVATE :: read_n7
    !> @copybrief FileType_HDF5::read_l0
    !> @copydoc FileType_HDF5::read_l0
    PROCEDURE,PASS,PRIVATE :: read_l0
    !> @copybrief FileType_HDF5::read_l1
    !> @copydoc FileType_HDF5::read_l1
    PROCEDURE,PASS,PRIVATE :: read_l1
    !> @copybrief FileType_HDF5::read_l2
    !> @copydoc FileType_HDF5::read_l2
    PROCEDURE,PASS,PRIVATE :: read_l2
    !> @copybrief FileType_HDF5::read_l3
    !> @copydoc FileType_HDF5::read_l3
    PROCEDURE,PASS,PRIVATE :: read_l3
    !> @copybrief FileType_HDF5::read_l4
    !> @copydoc FileType_HDF5::read_l4
    PROCEDURE,PASS,PRIVATE :: read_l4
    !> @copybrief FileType_HDF5::read_l5
    !> @copydoc FileType_HDF5::read_l5
    PROCEDURE,PASS,PRIVATE :: read_l5
    !> @copybrief FileType_HDF5::read_l6
    !> @copydoc FileType_HDF5::read_l6
    PROCEDURE,PASS,PRIVATE :: read_l6
    !> @copybrief FileType_HDF5::read_l7
    !> @copydoc FileType_HDF5::read_l7
    PROCEDURE,PASS,PRIVATE :: read_l7
    !> @copybrief FileType_HDF5::read_st0_helper
    !> @copydoc FileType_HDF5::read_st0_helper
    PROCEDURE,PASS,PRIVATE :: read_st0_helper
    !> @copybrief FileType_HDF5::read_st0
    !> @copydoc FileType_HDF5::read_st0
    PROCEDURE,PASS,PRIVATE :: read_st0
    !> @copybrief FileType_HDF5::read_st1_helper
    !> @copydoc FileType_HDF5::read_st1_helper
    PROCEDURE,PASS,PRIVATE :: read_st1_helper
    !> @copybrief FileType_HDF5::read_st1
    !> @copydoc FileType_HDF5::read_st1
    PROCEDURE,PASS,PRIVATE :: read_st1
    !> @copybrief FileType_HDF5::read_st2_helper
    !> @copydoc FileType_HDF5::read_st2_helper
    PROCEDURE,PASS,PRIVATE :: read_st2_helper
    !> @copybrief FileType_HDF5::read_st2
    !> @copydoc FileType_HDF5::read_st2
    PROCEDURE,PASS,PRIVATE :: read_st2
    !> @copybrief FileType_HDF5::read_st3_helper
    !> @copydoc FileType_HDF5::read_st3_helper
    PROCEDURE,PASS,PRIVATE :: read_st3_helper
    !> @copybrief FileType_HDF5::read_st3
    !> @copydoc FileType_HDF5::read_st3
    PROCEDURE,PASS,PRIVATE :: read_st3
    !> @copybrief FileType_HDF5::read_c1
    !> @copydoc FileType_HDF5::read_c1
    PROCEDURE,PASS,PRIVATE :: read_c1
    !> @copybrief FileType_HDF5::read_pList
    !> @copydoc FileType_HDF5::read_pList
    PROCEDURE,PASS,PRIVATE :: read_pList
    !> Generic typebound interface for all @c read operations
    GENERIC :: fread => read_d1, read_d2, read_d3, read_d4, read_d5, read_d6,&
        read_d7, read_s1, read_s2, read_s3, read_s4, read_s5, read_s6, read_s7,&
        read_l1, read_l2, read_l3, read_l4, read_l5, read_l6, read_l7, read_b1,&
        read_b2, read_b3, read_st0_helper,read_st0, read_d0, read_s0, read_l0, &
        read_b0, read_st1, read_st1_helper,read_st2, read_st2_helper, read_st3,&
        read_st3_helper, read_n0, read_n1, read_n2, read_n3, read_n4, read_n5, &
        read_n6, read_n7, read_c1, read_pList
    !> Generic typebound interface for pointer-based read operations
    GENERIC :: freadp => read_dp4
    !> @copybrief FileType_HDF5::write_attribute_st0
    !> @copydoc FileType_HDF5_write_attribute_st0
    PROCEDURE,PASS,PRIVATE :: write_attribute_st0
    !> @copybrief FileType_HDF5::write_attribute_c0
    !> @copydoc FileType_HDF5_write_attribute_c0
    PROCEDURE,PASS,PRIVATE :: write_attribute_c0
    !> @copybrief FileType_HDF5::write_attribute_i0
    !> @copydoc FileType_HDF5_write_attribute_i0
    PROCEDURE,PASS,PRIVATE :: write_attribute_i0
    !> @copybrief FileType_HDF5::write_attribute_d0
    !> @copydoc FileType_HDF5_write_attribute_d0
    PROCEDURE,PASS,PRIVATE :: write_attribute_d0
    !> @copybrief FileType_HDF5::write_attribute_b0
    !> @copydoc FileType_HDF5_write_attribute_b0
    PROCEDURE,PASS,PRIVATE :: write_attribute_b0
    !> Generic typebound interface for all @c attribute writes
    GENERIC ::  write_attribute => write_attribute_st0, write_attribute_c0,&
        write_attribute_i0, write_attribute_d0,write_attribute_b0
    !> @copybrief FileType_HDF5::read_str_attribure_help
    !> @copydoc FileType_HDF5_read_str_attribure_help
    PROCEDURE,PASS,PRIVATE :: read_attribute_st0
    !> @copybrief FileType_HDF5::read_attribute_c0
    !> @copydoc FileType_HDF5_read_attribute_c0
    PROCEDURE,PASS,PRIVATE :: read_attribute_c0
    !> @copybrief FileType_HDF5::read_attribute_i0
    !> @copydoc FileType_HDF5_read_attribute_i0
    PROCEDURE,PASS,PRIVATE :: read_attribute_i0
    !> @copybrief FileType_HDF5::read_attribute_d0
    !> @copydoc FileType_HDF5_read_attribute_d0
    PROCEDURE,PASS,PRIVATE :: read_attribute_d0
    !> @copybrief FileType_HDF5::read_attribute_b0
    !> @copydoc FileType_HDF5_read_attribute_b0
    PROCEDURE,PASS,PRIVATE :: read_attribute_b0
    !> Generic typebound interface for all @c attribute writes
    GENERIC :: read_attribute => read_attribute_st0, read_attribute_c0,&
        read_attribute_i0, read_attribute_d0,read_attribute_b0
    !> @copybrief FileType_HDF5::getDataShape
    !> @copydoc FileType_HDF5::getDataShape
    PROCEDURE,PASS :: getDataShape
    !> @copybrief FileType_HDF5::getDataType
    !> @copydoc FileType_HDF5::getDataType
    PROCEDURE,PASS :: getDataType
ENDTYPE

!> @brief Type that is a container so as to have an array of pointers to HDF5 files
TYPE :: HDF5FilePtrArrayType
  !> @brief Pointer to a HDF5 file type
  CLASS(HDF5FileType),POINTER :: h5 => NULL()
ENDTYPE HDF5FilePtrArrayType

#ifdef FUTILITY_HAVE_HDF5
!> Variable for keeping track of the number of hdf5 files initialized
!> This variable will be used in logic to call the h5close_f(error)
!> which closes the interface.
INTEGER(SIK),SAVE :: nhdf5fileinuse=0
#endif
!> Variable to make sure that the hdf5 interface was opened, and thus
!> can then be closed.
LOGICAL(SBK),SAVE :: libh5Open=.FALSE.
!
!===============================================================================
CONTAINS
!
!-------------------------------------------------------------------------------
SUBROUTINE HDF5Open()
  INTEGER(SIK) :: herr
  herr=-1
#ifdef FUTILITY_HAVE_HDF5
  IF(.NOT.libh5Open) CALL H5open_f(herr)
#endif
  IF(herr == 0) libh5Open=.TRUE.
ENDSUBROUTINE HDF5Open
!
!-------------------------------------------------------------------------------
SUBROUTINE HDF5Close()
  INTEGER(SIK) :: herr
  herr=-1
#ifdef FUTILITY_HAVE_HDF5
  IF(libh5Open) CALL H5close_f(herr)
#endif
  IF(herr == 0) libh5Open=.FALSE.
ENDSUBROUTINE HDF5Close
!
!-------------------------------------------------------------------------------
!> @brief   Enable/disable HDF5 exception writing
!> @param   quiet Set to .TRUE. to disable HDF5 exceptions from being printed
SUBROUTINE HDF5Quiet(quiet)
  LOGICAL,INTENT(IN) :: quiet
#ifdef FUTILITY_HAVE_HDF5
  IF(quiet) THEN
     CALL h5eset_auto_f(0, error)
  ELSE
     CALL h5eset_auto_f(1, error)
  ENDIF
#endif
ENDSUBROUTINE

!
!-------------------------------------------------------------------------------
!> @brief Initializes an HDF5 file object.
!> @param thisHDF5File the object to be initialized
!> @param filename the relative path to the file on the filesystem
!> @param mode the access mode. Can be 'READ', 'WRITE', 'OVERWRITE', or 'NEW'.
!>        Status 'READ', 'WRITE', and 'OVERWRITE' all require the file to
!>        exist.
!>        'WRITE' gives write access but will fail if the user tries to overwrite
!>        data existing in the file, whereas 'OVERWRITE' will allow the user to
!>        overwrite existing data in the file.
!>        'NEW' will create the file, overwriting any existing files with the
!>        same name.  File will be given 'WRITE' status.  Use setOverwriteStat
!>        to change the status to 'OVERWRITE'.
!>        Note that when overwriting datasets, new datasets must be the same
!>        type and shape as the existing one being overwritten; otherwise
!>        an exception will be thrown.
!> @param zlibOpt numeric option for GZIP compression [0-9] uses compression, -1
!>        is no compression
!>
!> This routine initializes an HDF5 file object by setting the objects
!> attributes, initializing the HDF5 library interface and calling the @c open
!> routine.
!>
SUBROUTINE init_HDF5FileType(thisHDF5File,filename,mode,zlibOpt)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: filename
  CHARACTER(LEN=*),INTENT(IN) :: mode
  INTEGER(SIK),INTENT(IN),OPTIONAL :: zlibOpt
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='init_HDF5FileType'
  TYPE(StringType) :: fpath,fname,fext,mode_in
  INTEGER(SIK) :: unitno
  LOGICAL(SBK) :: ostat,exists

  REQUIRE(.NOT.thisHDF5File%isInit)

  CALL getFileParts(filename,fpath,fname,fext,thisHDF5File%e)
  CALL thisHDF5File%setFilePath(CHAR(fpath))
  CALL thisHDF5File%setFileName(CHAR(fname))
  CALL thisHDF5File%setFileExt(CHAR(fext))

  IF(PRESENT(zlibOpt)) THEN
    IF(zlibOpt >= 0) THEN
      thisHDF5File%hasCompression=.TRUE.
      thisHDF5File%zlibOpt=zlibOpt
    ENDIF
  ENDIF

  ! Store the access mode
  mode_in=mode
  mode_in = mode_in%upper()
  SELECTCASE(TRIM(mode_in))
  CASE('READ')
    INQUIRE(FILE=filename,EXIST=exists)
    IF(exists) THEN
      CALL thisHDF5File%setWriteStat(.FALSE.)
      CALL thisHDF5File%setReadStat(.TRUE.)
    ELSE
      CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
          ' - HDF5 file '//filename//' is being opened with '// &
          'mode READ but does not exist.')
    ENDIF
  CASE('WRITE')
    INQUIRE(FILE=filename,EXIST=exists)
    IF(exists) THEN
      CALL thisHDF5File%setWriteStat(.TRUE.)
      CALL thisHDF5File%setReadStat(.TRUE.)
    ELSE
      CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
          ' - HDF5 file '//filename//' is being opened with '// &
          'mode WRITE but does not exist.')
    ENDIF
  CASE('OVERWRITE')
    INQUIRE(FILE=filename,EXIST=exists)
    IF(exists) THEN
      CALL thisHDF5File%setWriteStat(.TRUE.)
      CALL thisHDF5File%setOverwriteStat(.TRUE.)
      CALL thisHDF5File%setReadStat(.TRUE.)
    ELSE
      CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
          ' - HDF5 file '//filename//' is being opened with '// &
          'mode OVERWRITE but does not exist.')
    ENDIF
  CASE('NEW')
    CALL thisHDF5File%setWriteStat(.TRUE.)
    CALL thisHDF5File%setNewStat(.TRUE.)
    CALL thisHDF5File%setReadStat(.TRUE.)
  CASE DEFAULT
    CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
        ' - Unrecognized access mode.')
  ENDSELECT

  thisHDF5File%fullname=filename

  ! Initialize the HDF5 interface. This needs be done before any other calls
  ! to the HF5 interface can be made.
  CALL HDF5Open()

  ! Assign arbitrary UNIT number to file.  Used only for deleting file.
  unitno=99
  INQUIRE(UNIT=unitno,OPENED=ostat)
  DO WHILE(thisHDF5File%unitno == -1)
    IF(ostat) THEN
      unitno=unitno-1_SIK
      INQUIRE(UNIT=unitno,OPENED=ostat)
    ELSE
      thisHDF5File%unitno=unitno
    ENDIF
  ENDDO
  thisHDF5File%isinit=.TRUE.
  nhdf5fileinuse=nhdf5fileinuse+1
#else
  ! We dont have HDF5, so we can't initialize
  CALL thisHDF5File%e%raiseWarning('The HDF5 library is not present in '// &
      'this build')
#endif
ENDSUBROUTINE init_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Destructs an HDF5 file object.
!> @param thisHDF5File the HDF5 object to be destroyed
!> @param ldel logical on whether or not to delete or close the file.
!>
!> This routine releases resources used for interacting with the HSF5 file. It
!> closes or deletes the file and the HDF5 library interface. The structure
!> was taken from the Fortran file.
!>
SUBROUTINE clear_HDF5FileType(thisHDF5File,ldel)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  LOGICAL(SBK),INTENT(IN),OPTIONAL :: ldel
#ifdef FUTILITY_HAVE_HDF5
  LOGICAL(SBK) :: bool
#endif
  IF(thisHDF5File%isinit) THEN
#ifdef FUTILITY_HAVE_HDF5
    !Logical to close or delete the file.
    bool=.FALSE.
    IF(PRESENT(ldel)) bool=ldel
    IF(bool) THEN
      CALL thisHDF5File%fdelete()
    ELSE
      CALL thisHDF5File%fclose()
    ENDIF

    ! Close the HDF5 interface. This can only be done once all calls to the
    ! HDF5 library are complete.
    nhdf5fileinuse=nhdf5fileinuse-1
    IF(libh5Open .AND. (nhdf5fileinuse == 0)) CALL HDF5Close()
#endif
    thisHDF5File%isinit=.FALSE.
    thisHDF5File%newstat=.FALSE.
    thisHDF5File%hasCompression=.FALSE.
    thisHDF5File%zlibOpt=-1
    thisHDF5File%fullname=''
    thisHDF5File%unitno=-1
    thisHDF5File%overwriteStat = .FALSE.
    CALL clear_base_file(thisHDF5File)
  ENDIF
ENDSUBROUTINE clear_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Sets the value for the status of whether or not the file will
!> be overwritable.
!>
SUBROUTINE setOverwriteStat_file(file,bool)
  CLASS(HDF5FileType),INTENT(INOUT) :: file
  LOGICAL(SBK),INTENT(IN) :: bool
  file%overwriteStat=bool
ENDSUBROUTINE setOverwriteStat_file

!
!-------------------------------------------------------------------------------
!> @brief Open an HDF5 file
!> @param file the HDF5FileType object to open
!>
!> This routine implements the abstract @c fopen routine in the base file type.
!> It uses the HDF5 library interface that was initialized in @c init to open
!> the file.
!>
SUBROUTINE open_HDF5FileType(file)
  CLASS(HDF5FileType),INTENT(INOUT) :: file
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='open_HDF5FileType'
  INTEGER :: acc
  INTEGER(HID_T) :: plist_id

  REQUIRE(file%isinit)

  CALL h5pcreate_f(H5P_FILE_ACCESS_F,plist_id,error)
  CALL h5pset_fclose_degree_f(plist_id,H5F_CLOSE_SEMI_F,error)

  IF (error /= 0) CALL file%e%raiseError(modName//'::'//myName// &
      ' - Unable to create property list for open operation.')

  ! Decide what access type to use
  IF(file%isNew()) THEN
    acc=H5F_ACC_TRUNC_F
    CALL h5fcreate_f(CHAR(file%fullname),acc,file%file_id,error, &
        access_prp=plist_id)
    ! If the file is NEW, change the mode to WRITE after
    ! Creating it so we don't keep truncating it repeatedly.
    CALL file%setNewStat(.FALSE.)
  ELSEIF(file%isWrite()) THEN
    acc=H5F_ACC_RDWR_F
    CALL h5fopen_f(CHAR(file%fullname),acc,file%file_id,error, &
        access_prp=plist_id)
  ELSEIF(file%isRead()) THEN
    acc=H5F_ACC_RDONLY_F
    CALL h5fopen_f(CHAR(file%fullname),acc,file%file_id,error, &
        access_prp=plist_id)
  ELSE
    CALL file%e%raiseError(modName//'::'//myName// &
        ' - Unrecognized access mode! The file is not'// &
        ' set as either new, read, or write!')
  ENDIF

  CALL h5pclose_f(plist_id,error)
  IF(error /= 0) THEN
    CALL file%e%raiseError(modName//'::'//myName// &
        ' - Unable to destroy property list.')
  ELSE
    CALL file%setOpenStat(.TRUE.)
  ENDIF

#endif
ENDSUBROUTINE open_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Closes access to an HDF5 file
!> @param file the HDF5FileType object to close
!>
!> This routine implements the abstract @c fclose routine in the base file type.
!>
SUBROUTINE close_HDF5FileType(file)
  CLASS(HDF5FileType),INTENT(INOUT) :: file
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='close_HDF5FileType'
  LOGICAL(SBK) :: lastStopOnError

  REQUIRE(file%isinit)

  lastStopOnError=file%e%isStopOnError()
  CALL file%e%setStopOnError(.FALSE.)

  !Check open status.
  IF(file%isopen()) THEN
    CALL h5fclose_f(file%file_id,error)
    file%file_id=0
    IF(error /= 0) THEN
      CALL file%e%raiseError(modName//'::'//myName// &
          ' - Unable to close HDF5 file.')
    ELSE
      CALL file%setOpenStat(.FALSE.)
    ENDIF
  ENDIF

  CALL file%e%setStopOnError(lastStopOnError)

#endif
ENDSUBROUTINE close_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief delete and HDF5 file
!>
!> @param file the HDF5FileType object to delet
!>
!> This routine implements the abstract @c fdelete routine in the base file
!> type.
!> Mimicking FileType_Fortran logical structure.  We do not clear the file
!> after it is deleted.
!>
SUBROUTINE delete_HDF5FileType(file)
  CLASS(HDF5FileType),INTENT(INOUT) :: file
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='delete_HDF5FileType'
  CHARACTER(LEN=EXCEPTION_MAX_MESG_LENGTH) :: emesg

  REQUIRE(file%isInit)

  !So, HDF5 is special in that the unitno assigned isn't used in the
  !fopen() operation.  So, regardless of the %isOpen() status, it needs
  !to be opened.
  OPEN(UNIT=file%unitno,FILE=TRIM(file%getFilePath())// &
      TRIM(file%getFileName())//TRIM(file%getFileExt()), &
      IOSTAT=error)
  IF(error /= 0) THEN
    WRITE(emesg,'(a,i4,a,i4)') 'Error deleting file (UNIT=', &
        file%unitno,') IOSTAT=',error
    CALL file%e%raiseError(modName//'::'//myName//' - '//emesg)
  ENDIF
  CLOSE(UNIT=file%unitno,STATUS='DELETE',IOSTAT=error)
  IF(error /= 0) THEN
    WRITE(emesg,'(a,i4,a,i4)') 'Error deleting file (UNIT=', &
        file%unitno,') IOSTAT=',error
    CALL file%e%raiseError(modName//'::'//myName//' - '//emesg)
  ELSE
    CALL file%setOpenStat(.FALSE.)
  ENDIF
#else
  ! We dont have HDF5, so we can't initialize
  CALL file%e%raiseWarning('The HDF5 library is not present in '// &
      'this build')
#endif
ENDSUBROUTINE delete_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief gets the unit number used by the HDF5 file
!> @param file the HDF5 file type object
!> @returns val the value of the unit number
!>
PURE FUNCTION getUnitNo_HDF5FileType(file) RESULT(val)
  CLASS(HDF5FileType),INTENT(IN) :: file
  INTEGER(SIK) :: val
  val=file%unitno
ENDFUNCTION getUnitNo_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Returns whether or not the HDF5 file is new.
!> @param file the HDF5 file type object
!> @returns bool TRUE/FALSE if the file is new
!>
PURE FUNCTION isNew_HDF5FileType(file) RESULT(bool)
  CLASS(HDF5FileType),INTENT(IN) :: file
  LOGICAL(SBK) :: bool
  bool=file%newstat
ENDFUNCTION isNew_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Sets whether or not the HDF5 file is new.
!> @param file the HDF5 file type object
!> @returns bool TRUE/FALSE to set the file to new or not, respectively.
!>
PURE SUBROUTINE setNewStat_HDF5FileType(file,bool)
  CLASS(HDF5FileType),INTENT(INOUT) :: file
  LOGICAL(SBK),INTENT(IN) :: bool
  file%newstat=bool
ENDSUBROUTINE setNewStat_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief List the contents of a group
!> @param thisHDF5File the HDF5FileType object to operate on
!> @param path the absolute path to the group of interest (group heirarchy
!> represented with '->')
!> @param objs the list of objects to be returned. See below.
!>
!> This routine is useful for discovering the contents of an HDF5 file. A path
!> to a group in the file is provided in the subroutine call and the names of
!> its constituents is stored in the objs list. If objs is passed in, it will be
!> deallocated and reallocated to the proper size to store the names of all of
!> the objects in the group.
!>
SUBROUTINE ls_HDF5FileType(thisHDF5File,path,objs)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
  TYPE(StringType),ALLOCATABLE,INTENT(INOUT) :: objs(:)
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='ls_HDF5FileType'
  CHARACTER(LEN=1024) :: tmpchar
  TYPE(StringType) :: path2
  INTEGER(HSIZE_T) :: i
  INTEGER(HID_T) :: grp_id
  INTEGER :: store_type,nlinks,max_corder

  REQUIRE(thisHDF5File%isinit)

  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  IF(ALLOCATED(objs)) THEN
    !objs=''
    DEALLOCATE(objs)
  ENDIF
  IF(isgrp_HDF5FileType(thisHDF5File,path)) THEN
    path2=convertPath(path)
    CALL h5gopen_f(thisHDF5File%file_id,CHAR(path2),grp_id,error)
    IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
        ' - Unable to open file.')

    CALL h5gget_info_f(grp_id,store_type,nlinks,max_corder,error)
    IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
        ' - Unable to get group information.')

    ALLOCATE(objs(nlinks))

    DO i=0,nlinks-1
      CALL h5lget_name_by_idx_f(thisHDF5File%file_id,CHAR(path2), &
          H5_INDEX_NAME_F,H5_ITER_INC_F,i,tmpchar,error)
      objs(i+1)=TRIM(tmpchar)
      IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
          ' - Unable to get object name.')
    ENDDO

    CALL h5gclose_f(grp_id, error)
    IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
        ' - Unable to close group.')
  ENDIF
#endif
ENDSUBROUTINE ls_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Creates a new group in the HDF file.
!> @param thisHDF5File the HDF5FileType object to operate on
!> @param path the path to the group to be created
!>
!> This routine is used to create a new group in an HDF5 file. It can only be
!> called if the file has write access.
!>
RECURSIVE SUBROUTINE mkdir_HDF5FileType(thisHDF5File,path)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myNAme='mkdir_HDF5FileType'
  TYPE(StringType) :: path2,path3
  INTEGER(HID_T) :: group_id
  LOGICAL :: dset_exists
  INTEGER(SIK) :: lastslash

  REQUIRE(thisHDF5File%isinit)
  REQUIRE(thisHDF5File%isWrite())

  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  ! Convert the path to use slashes
  path2=convertPath(path)

  lastslash=INDEX(path2,'/',.TRUE.)
  IF(lastslash > 1) THEN
    path3=path2%substr(1,lastslash-1)
    IF(.NOT.thisHDF5File%pathExists(CHAR(path3))) THEN
      CALL thisHDF5File%mkdir(CHAR(path3))
    ENDIF
  ENDIF
  CALL h5lexists_f(thisHDF5File%file_id,CHAR(path2),dset_exists,error)
  IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
      ' - invalid group path: '//path)

  IF(thisHDF5File%overwriteStat .AND. dset_exists) THEN
    ! If group exists, do nothing, but only if overwrites are allowed
    CONTINUE
  ELSE

    ! Create the group
    CALL h5gcreate_f(thisHDF5File%file_id,CHAR(path2),group_id,error)

    IF(error == 0) THEN
      ! Close the group
      CALL h5gclose_f(group_id,error)
      IF(error /= 0) CALL thisHDF5File%e%raiseDebug(modName//'::'// &
          myName//' - Failed to close HDF group')
    ELSE
      CALL thisHDF5File%e%raiseDebug(modName//'::'//myName// &
          ' - Failed to create HDF5 group.')
    ENDIF
  ENDIF
#endif
ENDSUBROUTINE mkdir_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Creates a new group in the HDF file.
!> @param thisHDF5File the HDF5FileType object to operate on
!> @param path the path to the group to be created
!>
!> This routine is used to create a new group in an HDF5 file. It can only be
!> called if the file has write access.
!>
SUBROUTINE mkalldir_HDF5FileType(thisHDF5File,path)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myNAme='mkalldir_HDF5FileType'
  INTEGER(SIK) :: i,nslash
  INTEGER(SIK),ALLOCATABLE :: slashloc(:)
  TYPE(StringType) :: path2,tmppath
  INTEGER(HID_T) :: group_id

  REQUIRE(thisHDF5File%isinit)
  REQUIRE(thisHDF5File%isWrite())

  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  error=0
  ! Convert the path to use slashes
  path2=convertPath(TRIM(path))
  CALL strfind(TRIM(CHAR(path2)),FSLASH,slashloc)
  nslash=SIZE(slashloc)
  DO i=1,nslash-1
    tmppath = path2%substr(1,slashloc(i+1)-1)
    IF(.NOT.pathexists_HDF5FileType(thisHDF5File,TRIM(CHAR(tmppath)))) THEN
      CALL h5gcreate_f(thisHDF5File%file_id,TRIM(CHAR(tmppath)),group_id,error)
      CALL h5gclose_f(group_id,error)
    ENDIF
  ENDDO
  DEALLOCATE(slashloc)
  ! Create the group
  IF(.NOT.pathexists_HDF5FileType(thisHDF5File,TRIM(CHAR(path2)))) &
      CALL h5gcreate_f(thisHDF5File%file_id,TRIM(CHAR(path2)),group_id,error)

  IF(error == 0) THEN
    ! Close the group
    CALL h5gclose_f(group_id,error)
    IF(error /= 0) CALL thisHDF5File%e%raiseDebug(modName//'::'// &
        myName//' - Failed to close HDF group')
  ELSE
    CALL thisHDF5File%e%raiseDebug(modName//'::'//myName// &
        ' - Failed to create HDF5 group.')
  ENDIF
#endif
ENDSUBROUTINE mkalldir_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Returns the number of objects in a group
!> @param thisHDF5File the HDF5FileType object to interrogate
!> @param path the group in the file to interrogate
!>
!> This function returns how many objects are in the group @c path.
!>
FUNCTION ngrp_HDF5FileType(thisHDF5File,path) RESULT(ngrp)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
  INTEGER(SIK) :: ngrp
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='ngrp_HDF5FileType'
  TYPE(StringType) :: path2
  INTEGER(HID_T) :: grp_id
  INTEGER :: store_type,nlinks,max_corder

  REQUIRE(thisHDF5File%isinit)

  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  path2=convertPath(path)

  CALL h5gopen_f(thisHDF5File%file_id,CHAR(path2),grp_id,error)
  IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
      ' - Could not open group in HDF5 file.')

  CALL h5gget_info_f(grp_id, store_type,nlinks,max_corder,error)
  IF(error /= 0) CALL thisHDF5File%e%raiseError(modName//'::'//myName// &
      ' - Could not get group info in HDF5 file.')

  ! Close the group
  CALL h5gclose_f(grp_id,error)
  IF(error /= 0) CALL thisHDF5File%e%raiseDebug(modName//'::'// &
      myName//' - Failed to close HDF group')

  ngrp=nlinks
#else
  ngrp=0
#endif
ENDFUNCTION ngrp_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Returns whether the group is a group type in the file or not.
!> @param thisHDF5File the HDF5FileType object to interrogate
!> @param path the group in the file to check if it is a group
!> @param bool the logical result of whether the specified group is a group.
!>
!> This function returns a logical corresponding to whether the group specified
!> by @c path is a group or not.
!>
FUNCTION isgrp_HDF5FileType(thisHDF5File,path) RESULT(bool)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
  LOGICAL(SBK) :: bool
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='isgrp_HDF5FileType'
  TYPE(StringType) :: path2
  INTEGER(HID_T) :: obj_id
  INTEGER(SIK) :: type

  REQUIRE(thisHDF5File%isinit)

  ! Make sure the object is initialized, and opened
  bool=.FALSE.
  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  bool=thisHDF5File%pathExists(path)
  IF(bool) THEN
    path2=convertPath(path)
    !Need to get the object ID from the path...
    CALL h5oopen_f(thisHDF5File%file_id,CHAR(path2),obj_id,error)
    IF(error == -1) THEN
      bool=.FALSE.
    ELSE
      CALL h5iget_type_f(obj_id,type,error)
      bool=(type == H5I_GROUP_F)
    ENDIF
    ! Close the object
    CALL h5oclose_f(obj_id,error)
    IF(error /= 0) CALL thisHDF5File%e%raiseDebug(modName//'::'// &
        myName//' - Failed to close HDF object!')
  ENDIF
#else
  bool=.FALSE.
#endif
ENDFUNCTION isgrp_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Returns whether the path exists in the file or not.
!> @param thisHDF5File the HDF5FileType object to interrogate
!> @param path the path in the file to check if it exists
!> @param bool the logical result of whether the specified path exists.
!>
!> This function returns a logical corresponding to whether the specified
!> @c path exists or not.
!>
FUNCTION pathexists_HDF5FileType(thisHDF5File,path) RESULT(bool)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
  LOGICAL(SBK) :: bool
#ifdef FUTILITY_HAVE_HDF5
  INTEGER :: iseg
  TYPE(StringType) :: strpath,path2
  TYPE(StringType),ALLOCATABLE :: segments(:)

  REQUIRE(thisHDF5File%isinit)

  ! Make sure the object is initialized, and opened
  bool=.FALSE.
  IF(.NOT.thisHDF5File%isOpen()) CALL thisHDF5File%fopen()
  strpath=convertPath(path)
  segments=strpath%split('/')
  bool=.TRUE.
  path2=''
  DO iseg=2,SIZE(segments)
    path2=path2//'/'//segments(iseg)
    CALL h5lexists_f(thisHDF5File%file_id,CHAR(path2),bool,error)
    IF(.NOT.bool) EXIT
  ENDDO !iseg
#else
  bool=.FALSE.
#endif
ENDFUNCTION pathexists_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief   Returns whether an HDF5 File or data set has compression
!> @param   thisHDF5File the HDF5FileType object to interrogate
!> @param   path (optional) the path to a dataset in the file, which must exist
!> @returns bool the logical result of whether the specified object has
!>          compression.
!>
!> If the path is present, then whether or not the dataset is compressed is
!> returned.
!>
!> If the path is ommitted then the value of the hasCompression attribute is
!> returned.
!>
!> If a non-existent path is passed, a DBC error is thrown.
!>
FUNCTION isCompressed_HDF5FileType(thisHDF5File,path) RESULT(bool)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN),OPTIONAL :: path
  LOGICAL(SBK) :: bool
#ifdef FUTILITY_HAVE_HDF5
  INTEGER(SIZE_T),PARAMETER :: namelen=180
  CHARACTER(LEN=namelen) :: filter_name
  INTEGER(SIK) :: i,nfilters,filter_id,flags,cd_values(1)
  INTEGER(HID_T) :: dset_id,dcpl
  INTEGER(SIZE_T) :: nelmts
  TYPE(StringType) :: path2

  bool=.FALSE.

  ! Make sure the object is initialized, and opened
  REQUIRE(thisHDF5File%isinit)
  REQUIRE(thisHDF5File%isOpen())

  IF(PRESENT(path)) THEN
    REQUIRE(pathexists_HDF5FileType(thisHDF5File,path))
    path2=convertPath(path)
    nelmts=1

    !Get the data set ID
    CALL h5dopen_f(thisHDF5File%file_id,TRIM(path2),dset_id,error)

    !Get the data set creation property list
    CALL h5dget_create_plist_f(dset_id,dcpl,error)

    !Get the number of filters on the data set, and loop over
    !them to find a compression filter
    CALL h5pget_nfilters_f(dcpl,nfilters,error)
    DO i=0,nfilters-1
      CALL h5pget_filter_f(dcpl,i,flags,nelmts,cd_values, &
          namelen,filter_name,filter_id,error)
      bool=ANY(filter_id == (/H5Z_FILTER_DEFLATE_F, &
          H5Z_FILTER_SZIP_F,H5Z_FILTER_NBIT_F,H5Z_FILTER_NBIT_F/))
      IF(bool) EXIT
    ENDDO
  ELSE
    bool=thisHDF5File%hasCompression
  ENDIF
#else
  bool=.FALSE.
#endif
ENDFUNCTION isCompressed_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief   Returns the chunk size of a dataset
!> @param   thisHDF5File the HDF5FileType object to interrogate
!> @param   path the path to a dataset in the file
!> @param   cdims allocatable array containing chunk sizes for each dimension
!>          of dataset.
!>
!> If a dataset does not have chunking or does not exist, then cdims is
!> returned unallocated.
!>
SUBROUTINE getChunkSize_HDF5FileType(thisHDF5File,path,cdims)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: path
  INTEGER(SLK),ALLOCATABLE,INTENT(OUT) :: cdims(:)

#ifdef FUTILITY_HAVE_HDF5
  INTEGER(SIK) :: ndims,layout
  INTEGER(HID_T) :: dset_id,dspace_id,dcpl
  INTEGER(HSIZE_T),ALLOCATABLE :: cdimsH5(:)
  TYPE(StringType) :: path2

  ! Make sure the object is initialized, and opened
  REQUIRE(thisHDF5File%isinit)
  REQUIRE(thisHDF5File%isOpen())
  IF(pathexists_HDF5FileType(thisHDF5File,path)) THEN
    path2=convertPath(path)

    !Get the data set ID, associated data space, and rank
    CALL h5dopen_f(thisHDF5File%file_id,TRIM(path2),dset_id,error)
    CALL h5dget_space_f(dset_id,dspace_id,error)
    CALL h5sget_simple_extent_ndims_f(dspace_id,ndims,error)

    !Get the data set creation property list
    CALL h5dget_create_plist_f(dset_id,dcpl,error)

    !Get the data space layout and chunk size
    CALL h5pget_layout_f(dcpl,layout,error)
    IF(layout == H5D_CHUNKED_F) THEN
      ALLOCATE(cdims(ndims)); cdims=-1
      ALLOCATE(cdimsH5(ndims)); cdimsH5=-1
      CALL h5pget_chunk_f(dcpl,ndims,cdimsH5,error)
      cdims=cdimsH5
    ENDIF
  ENDIF
#endif
ENDSUBROUTINE getChunkSize_HDF5FileType
!
!-------------------------------------------------------------------------------
!> @brief Creates a hard link between 2 datasets
!> @param thisHDF5File the HDF5FileType object to interrogate
!> @param source_path the path in the file to create a link to
!> @param link_path the path of the link
!>
!>
SUBROUTINE createHardLink_HDF5FileType(thisHDF5File,source_path,link_path)
  CLASS(HDF5FileType),INTENT(INOUT) :: thisHDF5File
  CHARACTER(LEN=*),INTENT(IN) :: source_path
  CHARACTER(LEN=*),INTENT(IN) :: link_path
#ifdef FUTILITY_HAVE_HDF5
  CHARACTER(LEN=*),PARAMETER :: myName='createHardLink_HDF5FileType'
  INTEGER(HID_T) :: src_obj_id
  TYPE(StringType) :: spath,lpath

  INTERFACE
    FUNCTION H5Oclose(object_id) RESULT(herr_t) BIND(C,NAME="H5Oclose")
      USE ISO_C_BINDING
      USE HDF5
      INTEGER(HID_T),VALUE :: object_id
      INTEGER :: herr_t
    ENDFUNCTION H5Oclose
  ENDINTERFACE


  IF(pathexists_HDF5FileType(thisHDF5File,source_path)) THEN
    IF(.NOT.pathexists_HDF5FileType(thisHDF5File,link_path)) THEN
      spath=convertPath(source_path)
      lpath=convertPath(link_path)

      !Get the source object ID
      CALL H5Oopen_f(thisHDF5File%file_id,CHAR(spath),src_obj_id,error)

      !Create the link target object ID
      CALL H5Lcreate_hard_f(src_obj_id,CHAR(spath),thisHDF5File%file_id, &
          CHAR(lpath),error)

      !Close the source object
      !CALL H5Oclose_f(src_obj_id,error)
      error=H5Oclose(src_obj_id)
    ELSE
      CALL thisHDF5File%e%raiseError(modName//'::'//myName// &