    {-# LINE 1 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 4 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 6 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |The Virtual File Layer as described in documentation.
    -- This is the greatest common denominator for all types of
    -- storage access whether a file, memory, network, etc. This
    -- layer usually just dispatches the request to an actual
    -- file driver layer.
    module Bindings.HDF5.Raw.H5FD where

    import Data.Word
    import Foreign.Ptr
    import Foreign.C.String
    import Foreign.C.Types
    import Foreign.Marshal.Array
    import Foreign.Storable

    import Bindings.HDF5.Raw.H5
    import Bindings.HDF5.Raw.H5F
    import Bindings.HDF5.Raw.H5I
    import Foreign.Ptr.Conventions

    -- |Default VFL driver value
    h5fd_VFD_DEFAULT :: HId_t
    h5fd_VFD_DEFAULT :: HId_t
    h5fd_VFD_DEFAULT = Int64 -> HId_t
    HId_t (Int64
    0)

    {-# LINE 28 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Types of allocation requests: see "Bindings.HDF5.Raw.H5F"
    type H5FD_mem_t = H5F_mem_t

    -- |Map "fractal heap" header blocks to 'ohdr' type file memory, since its
    -- a fair amount of work to add a new kind of file memory and they are similar
    -- enough to object headers and probably too minor to deserve their own type.
    h5fd_MEM_FHEAP_HDR :: H5F_mem_t
    h5fd_MEM_FHEAP_HDR :: H5F_mem_t
    h5fd_MEM_FHEAP_HDR = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 36 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "fractal heap" indirect blocks to 'ohdr' type file memory, since they
    -- are similar to fractal heap header blocks.
    h5fd_MEM_FHEAP_IBLOCK :: H5F_mem_t
    h5fd_MEM_FHEAP_IBLOCK :: H5F_mem_t
    h5fd_MEM_FHEAP_IBLOCK = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 40 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "fractal heap" direct blocks to 'lheap' type file memory, since they
    -- will be replacing local heaps.
    h5fd_MEM_FHEAP_DBLOCK :: H5F_mem_t
    h5fd_MEM_FHEAP_DBLOCK :: H5F_mem_t
    h5fd_MEM_FHEAP_DBLOCK = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    5)

    {-# LINE 44 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "fractal heap" 'huge' objects to 'draw' type file memory, since they
    -- represent large objects that are directly stored in the file.
    h5fd_MEM_FHEAP_HUGE_OBJ :: H5F_mem_t
    h5fd_MEM_FHEAP_HUGE_OBJ :: H5F_mem_t
    h5fd_MEM_FHEAP_HUGE_OBJ = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    3)

    {-# LINE 48 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "free space" header blocks to 'ohdr' type file memory, since its
    -- a fair amount of work to add a new kind of file memory and they are similar
    -- enough to object headers and probably too minor to deserve their own type.
    h5fd_MEM_FSPACE_HDR :: H5F_mem_t
    h5fd_MEM_FSPACE_HDR :: H5F_mem_t
    h5fd_MEM_FSPACE_HDR = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 53 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "free space" serialized sections to 'lheap' type file memory, since they
    -- are similar enough to local heap info.
    h5fd_MEM_FSPACE_SINFO :: H5F_mem_t
    h5fd_MEM_FSPACE_SINFO :: H5F_mem_t
    h5fd_MEM_FSPACE_SINFO = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    5)

    {-# LINE 57 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "shared object header message" master table to 'ohdr' type file memory,
    -- since its a fair amount of work to add a new kind of file memory and they are
    -- similar enough to object headers and probably too minor to deserve their own
    -- type.
    h5fd_MEM_SOHM_TABLE :: H5F_mem_t
    h5fd_MEM_SOHM_TABLE :: H5F_mem_t
    h5fd_MEM_SOHM_TABLE = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 63 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "shared object header message" indices to 'btree' type file memory,
    -- since they are similar enough to B-tree nodes.
    h5fd_MEM_SOHM_INDEX :: H5F_mem_t
    h5fd_MEM_SOHM_INDEX :: H5F_mem_t
    h5fd_MEM_SOHM_INDEX = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    2)

    {-# LINE 67 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- Array initializers: pass a buffer and the size of that buffer (in bytes)
    -- and it will be filled as prescribed by the corresponding array-literal macro.
    --
    -- TODO: create statically-allocated constant versions of these?
    -- TODO: explain more in haddock docs about how to use these

    -- |Initialize a free-list map which maps all types of allocation requests
    -- to a single free list.  This is useful for drivers that don't really care
    -- about keeping different requests segregated in the underlying file and which
    -- want to make most efficient reuse of freed memory.  The use of the
    -- 'h5fd_MEM_SUPER' free list is arbitrary.
    foreign import ccall "inline_H5FD_FLMAP_SINGLE" h5fd_FLMAP_SINGLE
      :: OutArray H5FD_mem_t -> CSize -> IO ()

    {-# LINE 81 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |A free-list map which segregates requests into \"raw\" or \"meta\" data
    -- pools.
    foreign import ccall "inline_H5FD_FLMAP_DICHOTOMY" h5fd_FLMAP_DICHOTOMY
      :: OutArray H5FD_mem_t -> CSize -> IO ()

    {-# LINE 85 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |The default free list map which causes each request type to use its own
    -- free-list.
    foreign import ccall "inline_H5FD_FLMAP_DEFAULT" h5fd_FLMAP_DEFAULT
      :: OutArray H5FD_mem_t -> CSize -> IO ()

    {-# LINE 89 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_AGGREGATE_METADATA' for a VFL driver means that
    -- the library will attempt to allocate a larger block for metadata and
    -- then sub-allocate each metadata request from that larger block.
    h5fd_FEAT_AGGREGATE_METADATA :: forall a. Num a => a
    h5fd_FEAT_AGGREGATE_METADATA = a
    1
    h5fd_FEAT_AGGREGATE_METADATA :: (Num a) => a

    {-# LINE 94 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_ACCUMULATE_METADATA' for a VFL driver means that
    -- the library will attempt to cache metadata as it is written to the file
    -- and build up a larger block of metadata to eventually pass to the VFL
    -- 'write' routine.
    --
    -- Distinguish between updating the metadata accumulator on writes
    -- ('h5fd_FEAT_ACCUMULATE_METADATA_WRITE') and reads
    -- ('h5fd_FEAT_ACCUMULATE_METADATA_READ').  This is particularly (perhaps
    -- only, even) important for MPI-I/O where we guarantee that writes are
    -- collective, but reads may not be.  If we were to allow the metadata
    -- accumulator to be written during a read operation, the application would
    -- hang.
    h5fd_FEAT_ACCUMULATE_METADATA :: forall a. Num a => a
    h5fd_FEAT_ACCUMULATE_METADATA = a
    6
    h5fd_FEAT_ACCUMULATE_METADATA :: (Num a) => a

    {-# LINE 108 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FEAT_ACCUMULATE_METADATA_WRITE = 2
    h5fd_FEAT_ACCUMULATE_METADATA_WRITE :: (Num a) => a

    {-# LINE 109 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FEAT_ACCUMULATE_METADATA_READ = 4
    h5fd_FEAT_ACCUMULATE_METADATA_READ :: (Num a) => a

    {-# LINE 110 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_DATA_SIEVE' for a VFL driver means that
    -- the library will attempt to cache raw data as it is read from/written to
    -- a file in a "data seive" buffer.  See Rajeev Thakur's papers:
    --
    --  * <http://www.mcs.anl.gov/~thakur/papers/romio-coll.ps.gz>
    --
    --  * <http://www.mcs.anl.gov/~thakur/papers/mpio-high-perf.ps.gz>
    h5fd_FEAT_DATA_SIEVE :: forall a. Num a => a
    h5fd_FEAT_DATA_SIEVE = a
    8
    h5fd_FEAT_DATA_SIEVE :: (Num a) => a

    {-# LINE 119 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_AGGREGATE_SMALLDATA' for a VFL driver means that
    -- the library will attempt to allocate a larger block for \"small\" raw data
    -- and then sub-allocate \"small\" raw data requests from that larger block.
    h5fd_FEAT_AGGREGATE_SMALLDATA :: forall a. Num a => a
    h5fd_FEAT_AGGREGATE_SMALLDATA = a
    16
    h5fd_FEAT_AGGREGATE_SMALLDATA :: (Num a) => a

    {-# LINE 124 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_IGNORE_DRVRINFO' for a VFL driver means that
    -- the library will ignore the driver info that is encoded in the file
    -- for the VFL driver.  (This will cause the driver info to be eliminated
    -- from the file when it is flushed/closed, if the file is opened R/W).
    h5fd_FEAT_IGNORE_DRVRINFO :: forall a. Num a => a
    h5fd_FEAT_IGNORE_DRVRINFO = a
    32
    h5fd_FEAT_IGNORE_DRVRINFO :: (Num a) => a

    {-# LINE 130 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_DIRTY_SBLK_LOAD' for a VFL driver means that
    -- the library will mark the superblock dirty when the file is opened
    -- R/W.  This will cause the driver info to be re-encoded when the file
    -- is flushed/closed.
    h5fd_FEAT_DIRTY_DRVRINFO_LOAD :: forall a. Num a => a
    h5fd_FEAT_DIRTY_DRVRINFO_LOAD = a
    64
    h5fd_FEAT_DIRTY_DRVRINFO_LOAD :: (Num a) => a

    {-# LINE 136 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'h5fd_FEAT_POSIX_COMPAT_HANDLE' for a VFL driver means that
    -- the handle for the VFD (returned with the 'get_handle' callback) is
    -- of type 'int' and is compatible with POSIX I/O calls.
    h5fd_FEAT_POSIX_COMPAT_HANDLE :: forall a. Num a => a
    h5fd_FEAT_POSIX_COMPAT_HANDLE = a
    128
    h5fd_FEAT_POSIX_COMPAT_HANDLE :: (Num a) => a

    {-# LINE 141 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'H5FD_FEAT_ALLOW_FILE_IMAGE' for a VFL driver means that
    -- the driver is able to use a file image in the fapl as the initial
    -- contents of a file.
    h5fd_FEAT_ALLOW_FILE_IMAGE :: forall a. Num a => a
    h5fd_FEAT_ALLOW_FILE_IMAGE = a
    1024
    h5fd_FEAT_ALLOW_FILE_IMAGE :: (Num a) => a

    {-# LINE 146 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'H5FD_FEAT_CAN_USE_FILE_IMAGE_CALLBACKS' for a VFL driver
    -- means that the driver is able to use callbacks to make a copy of the
    -- image to store in memory.
    h5fd_FEAT_CAN_USE_FILE_IMAGE_CALLBACKS :: forall a. Num a => a
    h5fd_FEAT_CAN_USE_FILE_IMAGE_CALLBACKS = a
    2048
    h5fd_FEAT_CAN_USE_FILE_IMAGE_CALLBACKS :: (Num a) => a

    {-# LINE 151 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Class information for each file driver

    {-# LINE 154 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 155 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 156 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 157 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 158 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 159 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 160 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 161 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 162 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 163 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 164 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 165 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 166 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 167 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 168 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 169 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 170 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 171 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 172 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 173 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 174 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 175 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 176 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 177 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 178 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 179 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 180 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 181 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 182 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 183 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 184 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 185 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 186 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    data H5FD_class_t = H5FD_class_t{
      h5fd_class_t'name :: CString,
      h5fd_class_t'maxaddr :: HAddr_t,
      h5fd_class_t'fc_degree :: H5F_close_degree_t,
      h5fd_class_t'terminate :: FunPtr (IO HErr_t),
      h5fd_class_t'sb_size :: FunPtr (In H5FD_t -> IO HSize_t),
      h5fd_class_t'sb_encode :: FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t),
      h5fd_class_t'sb_decode :: FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t),
      h5fd_class_t'fapl_size :: CSize,
      h5fd_class_t'fapl_get :: FunPtr (In H5FD_t -> IO (Ptr ())),
      h5fd_class_t'fapl_copy :: FunPtr (Ptr () -> IO (Ptr ())),
      h5fd_class_t'fapl_free :: FunPtr (Ptr () -> IO HErr_t),
      h5fd_class_t'dxpl_size :: CSize,
      h5fd_class_t'dxpl_copy :: FunPtr (Ptr () -> IO (Ptr ())),
      h5fd_class_t'dxpl_free :: FunPtr (Ptr () -> IO HErr_t),
      h5fd_class_t'open :: FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)),
      h5fd_class_t'close :: FunPtr (In H5FD_t -> IO HErr_t),
      h5fd_class_t'cmp :: FunPtr (In H5FD_t -> In H5FD_t -> IO CInt),
      h5fd_class_t'query :: FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t),
      h5fd_class_t'get_type_map :: FunPtr (In H5FD_t -> Out H5FD_mem_t -> IO HErr_t),
      h5fd_class_t'alloc :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HSize_t -> IO HAddr_t),
      h5fd_class_t'free :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t),
      h5fd_class_t'get_eoa :: FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t),
      h5fd_class_t'set_eoa :: FunPtr (In H5FD_t -> H5FD_mem_t -> HAddr_t),
      h5fd_class_t'get_eof :: FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t),
      h5fd_class_t'get_handle :: FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t),
      h5fd_class_t'read :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> OutArray () -> IO HErr_t),
      h5fd_class_t'write :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> InArray () -> IO HErr_t),
      h5fd_class_t'flush :: FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t),
      h5fd_class_t'truncate :: FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t),
      h5fd_class_t'lock :: FunPtr (In H5FD_t -> HBool_t -> IO HErr_t),
      h5fd_class_t'unlock :: FunPtr (In H5FD_t -> IO HErr_t),
      h5fd_class_t'fl_map :: [H5FD_mem_t]
    } deriving (Eq,Show)
    p'H5FD_class_t'name :: Ptr H5FD_class_t -> Ptr CString
    p'H5FD_class_t'name Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    8
    p'H5FD_class_t'name :: Ptr (H5FD_class_t) -> Ptr (CString)
    p'H5FD_class_t'maxaddr :: Ptr H5FD_class_t -> Ptr HAddr_t
    p'H5FD_class_t'maxaddr Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr HAddr_t
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    16
    p'H5FD_class_t'maxaddr :: Ptr (H5FD_class_t) -> Ptr (HAddr_t)
    p'H5FD_class_t'fc_degree :: Ptr H5FD_class_t -> Ptr H5F_close_degree_t
    p'H5FD_class_t'fc_degree Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr H5F_close_degree_t
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    24
    p'H5FD_class_t'fc_degree :: Ptr (H5FD_class_t) -> Ptr (H5F_close_degree_t)
    p'H5FD_class_t'terminate :: Ptr H5FD_class_t -> Ptr (FunPtr (IO HErr_t))
    p'H5FD_class_t'terminate Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    32
    p'H5FD_class_t'terminate :: Ptr (H5FD_class_t) -> Ptr (FunPtr (IO HErr_t))
    p'H5FD_class_t'sb_size :: Ptr H5FD_class_t -> Ptr (FunPtr (In H5FD_t -> IO HSize_t))
    p'H5FD_class_t'sb_size Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (In H5FD_t -> IO HSize_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    40
    p'H5FD_class_t'sb_size :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> IO HSize_t))
    p'H5FD_class_t'sb_encode :: Ptr H5FD_class_t
    -> Ptr
         (FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t))
    p'H5FD_class_t'sb_encode Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int
    -> Ptr
         (FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    48
    h5fd_FILE_IMAGE_OP_NO_OP :: H5FD_file_image_op_t
    p'H5FD_class_t'sb_encode :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t))
    p'H5FD_class_t'sb_decode :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t))
    p'H5FD_class_t'sb_decode Ptr H5FD_class_t
    p = plusPtr p 56
    p'H5FD_class_t'sb_decode :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t))
    p'H5FD_class_t'fapl_size p = plusPtr p 64
    p'H5FD_class_t'fapl_size :: Ptr (H5FD_class_t) -> Ptr (CSize)
    p'H5FD_class_t'fapl_get :: Ptr H5FD_class_t -> Ptr (FunPtr (In H5FD_t -> IO (Ptr ())))
    p'H5FD_class_t'fapl_get Ptr H5FD_class_t
    p = plusPtr p 72
    p'H5FD_class_t'fapl_get :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> IO (Ptr ())))
    p'H5FD_class_t'fapl_copy :: Ptr H5FD_class_t -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    p'H5FD_class_t'fapl_copy Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    80
    p'H5FD_class_t'fapl_copy :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    p'H5FD_class_t'fapl_free p = plusPtr p 88
    p'H5FD_class_t'fapl_free :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO HErr_t))
    p'H5FD_class_t'dxpl_size :: Ptr H5FD_class_t -> Ptr CSize
    p'H5FD_class_t'dxpl_size Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr CSize
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    96
    p'H5FD_class_t'dxpl_size :: Ptr (H5FD_class_t) -> Ptr (CSize)
    p'H5FD_class_t'dxpl_copy :: Ptr H5FD_class_t -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    p'H5FD_class_t'dxpl_copy Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    104
    p'H5FD_class_t'dxpl_copy :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    p'H5FD_class_t'dxpl_free :: Ptr H5FD_class_t -> Ptr (FunPtr (Ptr () -> IO HErr_t))
    p'H5FD_class_t'dxpl_free Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (Ptr () -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    112
    p'H5FD_class_t'dxpl_free :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO HErr_t))
    p'H5FD_class_t'open :: Ptr H5FD_class_t
    -> Ptr
         (FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)))
    p'H5FD_class_t'open Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int
    -> Ptr
         (FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    120
    p'H5FD_class_t'open :: Ptr (H5FD_class_t) -> Ptr (FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)))
    p'H5FD_class_t'close :: Ptr H5FD_class_t -> Ptr (FunPtr (In H5FD_t -> IO HErr_t))
    p'H5FD_class_t'close Ptr H5FD_class_t
    p = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (In H5FD_t -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    128
    p'H5FD_class_t'close :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> IO HErr_t))
    p'H5FD_class_t'cmp :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> In H5FD_t -> IO CInt))
    p'H5FD_class_t'cmp Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> In H5FD_t -> IO CInt))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    136
    p'H5FD_class_t'cmp :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> In H5FD_t -> IO CInt))
    p'H5FD_class_t'query :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t))
    p'H5FD_class_t'query Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    144
    p'H5FD_class_t'query :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t))
    p'H5FD_class_t'get_type_map :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t))
    p'H5FD_class_t'get_type_map Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    152
    p'H5FD_class_t'get_type_map :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> Out H5FD_mem_t -> IO HErr_t))
    p'H5FD_class_t'alloc :: Ptr H5FD_class_t
    -> Ptr
         (FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t))
    p'H5FD_class_t'alloc Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int
    -> Ptr
         (FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    160
    p'H5FD_class_t'alloc :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HSize_t -> IO HAddr_t))
    p'H5FD_class_t'free :: Ptr H5FD_class_t
    -> Ptr
         (FunPtr
            (In H5FD_t
             -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t))
    p'H5FD_class_t'free Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int
    -> Ptr
         (FunPtr
            (In H5FD_t
             -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    168
    p'H5FD_class_t'free :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t))
    p'H5FD_class_t'get_eoa :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
    p'H5FD_class_t'get_eoa Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    176
    p'H5FD_class_t'get_eoa :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t))
    p'H5FD_class_t'set_eoa :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t))
    p'H5FD_class_t'set_eoa Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    184
    p'H5FD_class_t'set_eoa :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> HAddr_t))
    p'H5FD_class_t'get_eof p = plusPtr p 192
    p'H5FD_class_t'get_eof :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t))
    p'H5FD_class_t'get_handle p = plusPtr p 200
    p'H5FD_class_t'get_handle :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t))
    p'H5FD_class_t'read p = plusPtr p 208
    p'H5FD_class_t'read :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> OutArray () -> IO HErr_t))
    p'H5FD_class_t'write p = plusPtr p 216
    p'H5FD_class_t'write :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> InArray () -> IO HErr_t))
    p'H5FD_class_t'flush :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t))
    p'H5FD_class_t'flush Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    256
    p'H5FD_class_t'flush :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t))
    p'H5FD_class_t'truncate :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t))
    p'H5FD_class_t'truncate Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    264
    p'H5FD_class_t'truncate :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t))
    p'H5FD_class_t'lock :: Ptr H5FD_class_t
    -> Ptr (FunPtr (In H5FD_t -> HBool_t -> IO HErr_t))
    p'H5FD_class_t'lock Ptr H5FD_class_t
    p = Ptr H5FD_class_t
    -> Int -> Ptr (FunPtr (In H5FD_t -> HBool_t -> IO HErr_t))
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr H5FD_class_t
    p Int
    272
    p'H5FD_class_t'lock :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> HBool_t -> IO HErr_t))
    p'H5FD_class_t'unlock p = plusPtr p 280
    p'H5FD_class_t'unlock :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> IO HErr_t))
    p'H5FD_class_t'fl_map p = plusPtr p 304
    p'H5FD_class_t'fl_map :: Ptr (H5FD_class_t) -> Ptr (H5FD_mem_t)
    instance Storable H5FD_class_t where
      sizeOf :: H5FD_class_t -> Int
    sizeOf H5FD_class_t
    _ = Int
    336
      alignment :: H5FD_class_t -> Int
    alignment H5FD_class_t
    _ = Int
    8
      peek :: Ptr H5FD_class_t -> IO H5FD_class_t
    peek Ptr H5FD_class_t
    _p = do
        v0 <- Ptr H5FD_class_t -> Int -> IO CString
    forall b. Ptr b -> Int -> IO CString
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr H5FD_class_t
    _p Int
    8
        v1 <- peekByteOff _p 16
        v2 <- peekByteOff _p 24
        v3 <- peekByteOff _p 32
        v4 <- peekByteOff _p 40
        v5 <- peekByteOff _p 48
        v6 <- peekByteOff _p 56
        v7 <- peekByteOff _p 64
        v8 <- peekByteOff _p 72
        v9 <- peekByteOff _p 80
        v10 <- peekByteOff _p 88
        v11 <- peekByteOff _p 96
        v12 <- peekByteOff _p 104
        v13 <- peekByteOff _p 112
        v14 <- peekByteOff _p 120
        v15 <- peekByteOff _p 128
        v16 <- peekByteOff _p 136
        v17 <- peekByteOff _p 144
        v18 <- peekByteOff _p 152
        v19 <- peekByteOff _p 160
        v20 <- peekByteOff _p 168
        v21 <- peekByteOff _p 176
        v22 <- peekByteOff _p 184
        v23 <- peekByteOff _p 192
        v24 <- peekByteOff _p 200
        v25 <- peekByteOff _p 208
        v26 <- peekByteOff _p 216
        v27 <- peekByteOff _p 256
        v28 <- peekByteOff _p 264
        v29 <- peekByteOff _p 272
        v30 <- peekByteOff _p 280
        v31 <- let s31 = Int -> Int -> Int
    forall a. Integral a => a -> a -> a
    div Int
    28 (Int -> Int) -> Int -> Int
    forall a b. (a -> b) -> a -> b
    $ H5F_mem_t -> Int
    forall a. Storable a => a -> Int
    sizeOf (H5F_mem_t -> Int) -> H5F_mem_t -> Int
    forall a b. (a -> b) -> a -> b
    $ (H5F_mem_t
    forall a. HasCallStack => a
    undefined :: H5FD_mem_t) in peekArray s31 (plusPtr _p 304)
        return $ H5FD_class_t v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 v21 v22 v23 v24 v25 v26 v27 v28 v29 v30 v31
      poke _p (H5FD_class_t v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 v21 v22 v23 v24 v25 v26 v27 v28 v29 v30 v31) = do
        pokeByteOff _p 8 v0
        pokeByteOff _p 16 v1
        pokeByteOff _p 24 v2
        pokeByteOff _p 32 v3
        pokeByteOff _p 40 v4
        pokeByteOff _p 48 v5
        pokeByteOff _p 56 v6
        pokeByteOff _p 64 v7
        pokeByteOff _p 72 v8
        pokeByteOff _p 80 v9
        pokeByteOff _p 88 v10
        pokeByteOff _p 96 v11
        pokeByteOff _p 104 v12
        pokeByteOff _p 112 v13
        pokeByteOff _p 120 v14
        pokeByteOff _p 128 v15
        pokeByteOff _p 136 v16
        pokeByteOff _p 144 v17
        pokeByteOff _p 152 v18
        pokeByteOff _p 160 v19
        pokeByteOff _p 168 v20
        pokeByteOff _p 176 v21
        pokeByteOff _p 184 v22
        pokeByteOff _p 192 v23
        pokeByteOff _p 200 v24
        pokeByteOff _p 208 v25
        pokeByteOff _p 216 v26
        pokeByteOff _p 256 v27
        pokeByteOff _p 264 v28
        pokeByteOff _p 272 v29
        pokeByteOff _p 280 v30
        let s31 = div 28 $ sizeOf $ (undefined :: H5FD_mem_t)
        pokeArray (plusPtr _p 304) (take s31 v31)
        return ()

    {-# LINE 187 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |A free list is a singly-linked list of address/size pairs.

    {-# LINE 191 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 192 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 193 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    {-# LINE 194 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    data H5FD_free_t = H5FD_free_t{
      h5fd_free_t'addr :: HAddr_t,
      h5fd_free_t'size :: HSize_t,
      h5fd_free_t'next :: Ptr H5FD_free_t
    } deriving (Eq,Show)
    p'H5FD_free_t'addr p = plusPtr p 0
    p'H5FD_free_t'addr :: Ptr (H5FD_free_t) -> Ptr (HAddr_t)
    p'H5FD_free_t'size p = plusPtr p 8
    p'H5FD_free_t'size :: Ptr (H5FD_free_t) -> Ptr (HSize_t)
    p'H5FD_free_t'next p = plusPtr p 16
    p'H5FD_free_t'next :: Ptr (H5FD_free_t) -> Ptr (Ptr H5FD_free_t)
    instance Storable H5FD_free_t where
      sizeOf _ = 24
      alignment _ = 8
      peek _p = do
        v0 <- peekByteOff _p 0
        v1 <- peekByteOff _p 8
        v2 <- peekByteOff _p 16
        return $ H5FD_free_t v0 v1 v2
      poke _p (H5FD_free_t v0 v1 v2) = do
        pokeByteOff _p 0 v0
        pokeByteOff _p 8 v1
        pokeByteOff _p 16 v2
        return ()

    {-# LINE 195 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |The main datatype for each driver. Public fields common to all drivers
    -- are declared here and the driver appends private fields in memory.

    {-# LINE 200 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |driver ID for this file

    {-# LINE 203 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |constant class info

    {-# LINE 206 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |File 'serial' number

    {-# LINE 209 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |VFL Driver feature Flags

    {-# LINE 212 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |For this file, overrides class

    {-# LINE 215 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Base address for HDF5 data w/in file

    {-# LINE 218 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- Space allocation management fields

    -- |Threshold for alignment

    {-# LINE 223 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    -- |Allocation alignment

    {-# LINE 225 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    data H5FD_t = H5FD_t{
      h5fd_t'driver_id :: HId_t,
      h5fd_t'cls :: Ptr H5FD_class_t,
      h5fd_t'fileno :: CULong,
      h5fd_t'feature_flags :: CULong,
      h5fd_t'maxaddr :: HAddr_t,
      h5fd_t'base_addr :: HAddr_t,
      h5fd_t'threshold :: HSize_t,
      h5fd_t'alignment :: HSize_t
    } deriving (Eq,Show)
    p'H5FD_t'driver_id p = plusPtr p 0
    p'H5FD_t'driver_id :: Ptr (H5FD_t) -> Ptr (HId_t)
    p'H5FD_t'cls p = plusPtr p 8
    p'H5FD_t'cls :: Ptr (H5FD_t) -> Ptr (Ptr H5FD_class_t)
    p'H5FD_t'fileno p = plusPtr p 16
    p'H5FD_t'fileno :: Ptr (H5FD_t) -> Ptr (CULong)
    p'H5FD_t'feature_flags p = plusPtr p 32
    p'H5FD_t'feature_flags :: Ptr (H5FD_t) -> Ptr (CULong)
    p'H5FD_t'maxaddr p = plusPtr p 40
    p'H5FD_t'maxaddr :: Ptr (H5FD_t) -> Ptr (HAddr_t)
    p'H5FD_t'base_addr p = plusPtr p 48
    p'H5FD_t'base_addr :: Ptr (H5FD_t) -> Ptr (HAddr_t)
    p'H5FD_t'threshold p = plusPtr p 56
    p'H5FD_t'threshold :: Ptr (H5FD_t) -> Ptr (HSize_t)
    p'H5FD_t'alignment p = plusPtr p 64
    p'H5FD_t'alignment :: Ptr (H5FD_t) -> Ptr (HSize_t)
    instance Storable H5FD_t where
      sizeOf _ = 80
      alignment _ = 8
      peek _p = do
        v0 <- peekByteOff _p 0
        v1 <- peekByteOff _p 8
        v2 <- peekByteOff _p 16
        v3 <- peekByteOff _p 32
        v4 <- peekByteOff _p 40
        v5 <- peekByteOff _p 48
        v6 <- peekByteOff _p 56
        v7 <- peekByteOff _p 64
        return $ H5FD_t v0 v1 v2 v3 v4 v5 v6 v7
      poke _p (H5FD_t v0 v1 v2 v3 v4 v5 v6 v7) = do
        pokeByteOff _p 0 v0
        pokeByteOff _p 8 v1
        pokeByteOff _p 16 v2
        pokeByteOff _p 32 v3
        pokeByteOff _p 40 v4
        pokeByteOff _p 48 v5
        pokeByteOff _p 56 v6
        pokeByteOff _p 64 v7
        return ()

    {-# LINE 226 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |enum for the source of file image callbacks
    newtype H5FD_file_image_op_t = H5FD_file_image_op_t Word32 deriving (Storable, Show)

    {-# LINE 229 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    h5fd_FILE_IMAGE_OP_NO_OP :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_NO_OP = H5FD_file_image_op_t (0)

    {-# LINE 231 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_SET :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_SET = H5FD_file_image_op_t (1)

    {-# LINE 232 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_COPY :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_COPY = H5FD_file_image_op_t (2)

    {-# LINE 233 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_GET :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_GET = H5FD_file_image_op_t (3)

    {-# LINE 234 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_CLOSE :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_PROPERTY_LIST_CLOSE = H5FD_file_image_op_t (4)

    {-# LINE 235 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_FILE_OPEN :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_FILE_OPEN = H5FD_file_image_op_t (5)

    {-# LINE 236 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_FILE_RESIZE :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_FILE_RESIZE = H5FD_file_image_op_t (6)

    {-# LINE 237 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_FILE_IMAGE_OP_FILE_CLOSE :: H5FD_file_image_op_t
    h5fd_FILE_IMAGE_OP_FILE_CLOSE = H5FD_file_image_op_t (7)

    {-# LINE 238 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |TODO: wrap this.  not tackling it now, because there are a lot of
    -- pointer types to pin down.
    data H5FD_file_image_callbacks_t = H5FD_file_image_callbacks_t

    -- /* Define structure to hold file image callbacks */
    -- typedef struct {
    --     void   *(*image_malloc)(size_t size, H5FD_file_image_op_t file_image_op,
    --                             void *udata);
    --     void   *(*image_memcpy)(void *dest, const void *src, size_t size,
    --                             H5FD_file_image_op_t file_image_op, void *udata);
    --     void   *(*image_realloc)(void *ptr, size_t size,
    --                             H5FD_file_image_op_t file_image_op, void *udata);
    --     herr_t  (*image_free)(void *ptr, H5FD_file_image_op_t file_image_op,
    --                           void *udata);
    --     void   *(*udata_copy)(void *udata);
    --     herr_t  (*udata_free)(void *udata);
    --     void *udata;
    -- } H5FD_file_image_callbacks_t;

    -- |Registers a new file driver as a member of the virtual file
    -- driver class.  Certain fields of the class struct are
    -- required and that is checked here so it doesn't have to be
    -- checked every time the field is accessed.
    --
    -- On success, returns a file driver ID which is good until the
    -- library is closed or the driver is unregistered.
    -- On failure, returns a negative value.
    --
    -- > hid_t H5FDregister(const H5FD_class_t *cls);
    foreign import ccall "H5FDregister" h5fd_register
      :: In H5FD_class_t -> IO HId_t
    foreign import ccall "&H5FDregister" p_H5FDregister
      :: FunPtr (In H5FD_class_t -> IO HId_t)

    {-# LINE 270 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Removes a driver ID from the library. This in no way affects
    -- file access property lists which have been defined to use
    -- this driver or files which are already opened under this
    -- driver.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDunregister(hid_t driver_id);
    foreign import ccall "H5FDunregister" h5fd_unregister
      :: HId_t -> IO HErr_t
    foreign import ccall "&H5FDunregister" p_H5FDunregister
      :: FunPtr (HId_t -> IO HErr_t)

    {-# LINE 280 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Opens a file named 'name' for the type(s) of access described
    -- by the bit vector 'flags' according to a file access property
    -- list 'fapl_id' (which may be the constant 'h5p_DEFAULT'). The
    -- file should expect to handle format addresses in the range [0,
    -- 'maxaddr'] (if 'maxaddr' is 'hADDR_UNDEF' then the caller
    -- doesn't care about the address range).
    --
    -- Possible values for the 'flags' bits are:
    --
    -- ['h5f_ACC_RDWR']
    --  Open the file for read and write access. If
    --  this bit is not set then open the file for
    --  read only access. It is permissible to open a
    --  file for read and write access when only read
    --  access is requested by the library (the
    --  library will never attempt to write to a file
    --  which it opened with only read access).
    --
    -- ['h5f_ACC_CREAT']
    --  Create the file if it doesn't already exist.
    --  However, see 'h5f_ACC_EXCL' below.
    --
    -- ['h5f_ACC_TRUNC']
    --  Truncate the file if it already exists. This
    --  is equivalent to deleting the file and then
    --  creating a new empty file.
    --
    -- ['h5f_ACC_EXCL']
    --  When used with 'h5f_ACC_CREAT', if the file
    --  already exists then the open should fail.
    --  Note that this is unsupported/broken with
    --  some file drivers (e.g., sec2 across nfs) and
    --  will contain a race condition when used to
    --  perform file locking.
    --
    -- The 'maxaddr' is the maximum address which will be requested by
    -- the library during an allocation operation. Usually this is
    -- the same value as the 'maxaddr' field of the class structure,
    -- but it can be smaller if the driver is being used under some
    -- other driver.
    --
    -- Note that when the driver 'open' callback gets control that
    -- the public part of the file struct (the 'H5FD_t' part) will be
    -- incomplete and will be filled in after that callback returns.
    --
    -- On success, returns a pointer to a new file driver struct.
    -- On failure, returns 'nullPtr'.
    --
    -- > H5FD_t *H5FDopen(const char *name, unsigned flags, hid_t fapl_id,
    -- >        haddr_t maxaddr);
    foreign import ccall "H5FDopen" h5fd_open
      :: CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)
    foreign import ccall "&H5FDopen" p_H5FDopen
      :: FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t))

    {-# LINE 332 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Closes the file by calling the driver 'close' callback, which
    -- should free all driver-private data and free the file struct.
    -- Note that the public part of the file struct (the 'H5FD_t' part)
    -- will be all zero during the driver close callback like during
    -- the 'open' callback.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDclose(H5FD_t *file);
    foreign import ccall "H5FDclose" h5fd_close
      :: In H5FD_t -> IO HErr_t
    foreign import ccall "&H5FDclose" p_H5FDclose
      :: FunPtr (In H5FD_t -> IO HErr_t)

    {-# LINE 343 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Compare the keys of two files using the file driver callback
    -- if the files belong to the same driver, otherwise sort the
    -- files by driver class pointer value.
    --
    -- Returns an integer greater than, less than, or equal to zero,
    -- indicating the corresponding ordering.
    --
    -- Must never fail. If both file handles are invalid then they
    -- compare equal. If one file handle is invalid then it compares
    -- less than the other.  If both files belong to the same driver
    -- and the driver doesn't provide a comparison callback then the
    -- file pointers themselves are compared.
    --
    -- > int H5FDcmp(const H5FD_t *f1, const H5FD_t *f2);
    foreign import ccall "H5FDcmp" h5fd_cmp
      :: In H5FD_t -> In H5FD_t -> IO CInt
    foreign import ccall "&H5FDcmp" p_H5FDcmp
      :: FunPtr (In H5FD_t -> In H5FD_t -> IO CInt)

    {-# LINE 359 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Query a VFL driver for its feature flags. (listed in
    -- "Bindings.HDF5.Raw.H5FD")
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > int H5FDquery(const H5FD_t *f, unsigned long *flags);
    foreign import ccall "H5FDquery" h5fd_query
      :: In H5FD_t -> Out CULong -> IO CInt
    foreign import ccall "&H5FDquery" p_H5FDquery
      :: FunPtr (In H5FD_t -> Out CULong -> IO CInt)

    {-# LINE 367 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Allocates 'size' bytes of memory from the 'file'. The memory will
    -- be used according to the allocation class 'type'. First we try
    -- to satisfy the request from one of the free lists, according
    -- to the free list map provided by the driver. The free list
    -- array has one entry for each request type and the value of
    -- that array element can be one of four possibilities:
    --
    -- * It can be the constant 'h5fd_MEM_DEFAULT' (or zero) which
    --   indicates that the identity mapping is used. In other
    --   words, the request type maps to its own free list.
    --
    -- * It can be the request type itself, which has the same
    --   effect as the 'h5fd_MEM_DEFAULT' value above.
    --
    -- * It can be the ID for another request type, which
    --   indicates that the free list for the specified type
    --   should be used instead.
    --
    -- * It can be the constant 'h5fd_MEM_NOLIST' which means that
    --   no free list should be used for this type of request.
    --
    -- If the request cannot be satisfied from a free list then
    -- either the driver's 'alloc' callback is invoked (if one was
    -- supplied) or the end-of-address marker is extended. The
    -- 'alloc' callback is always called with the same arguments as
    -- the 'h5fd_alloc'.
    --
    -- Returns the format address of the new file memory, or the
    -- undefined address 'hADDR_UNDEF' on failure.
    --
    -- > haddr_t H5FDalloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size);
    foreign import ccall "H5FDalloc" h5fd_alloc
      :: In H5FD_t -> H5FD_mem_t -> HId_t -> HSize_t -> IO HAddr_t
    foreign import ccall "&H5FDalloc" p_H5FDalloc
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HSize_t -> IO HAddr_t)

    {-# LINE 400 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Frees format addresses starting with 'addr' and continuing for
    -- 'size' bytes in the file 'file'. The type of space being freed is
    -- specified by 'type', which is mapped to a free list as
    -- described for the 'h5fd_alloc' function above.  If the request
    -- doesn't map to a free list then either the application 'free'
    -- callback is invoked (if defined) or the memory is leaked.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDfree(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id,
    -- >                        haddr_t addr, hsize_t size);
    foreign import ccall "H5FDfree" h5fd_free
      :: In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t
    foreign import ccall "&H5FDfree" p_H5FDfree
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t)

    {-# LINE 413 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Returns the address of the first byte after the last
    -- allocated memory in the file, or 'hADDR_UNDEF' on failure.
    --
    -- > haddr_t H5FDget_eoa(H5FD_t *file, H5FD_mem_t type);
    foreign import ccall "H5FDget_eoa" h5fd_get_eoa
      :: In H5FD_t -> H5FD_mem_t -> IO HAddr_t
    foreign import ccall "&H5FDget_eoa" p_H5FDget_eoa
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t)

    {-# LINE 419 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Set the end-of-address marker for the file. The 'addr' is the
    -- address of the first byte past the last allocated byte of the
    -- file. This function is called from two places:
    --
    --  1. It is called after an existing file is opened in order to
    --     \"allocate\" enough space to read the superblock and then
    --     to \"allocate\" the entire hdf5 file based on the contents
    --     of the superblock.
    --
    --  2. It is called during file memory allocation if the
    --     allocation request cannot be satisfied from the free list
    --     and the driver didn't supply an allocation callback.
    --
    -- Returns non-negative on success, or negative on failure.  If the
    -- operation fails, it will do so with no side-effects.
    --
    -- > herr_t H5FDset_eoa(H5FD_t *file, H5FD_mem_t type, haddr_t eoa);
    foreign import ccall "H5FDset_eoa" h5fd_set_eoa
      :: In H5FD_t -> H5FD_mem_t -> HAddr_t -> IO HErr_t
    foreign import ccall "&H5FDset_eoa" p_H5FDset_eoa
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> HAddr_t -> IO HErr_t)

    {-# LINE 438 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Returns the end-of-file address, which is the greater of the
    -- end-of-format address and the actual EOF marker. This
    -- function is called after an existing file is opened in order
    -- for the library to learn the true size of the underlying file
    -- and to determine whether the hdf5 data has been truncated.
    --
    -- It is also used when a file is first opened to learn whether
    -- the file is empty or not.
    --
    -- It is permissible for the driver to return the maximum address
    -- for the file size if the file is not empty.
    --
    -- On failure, returns 'hADDR_UNDEF'
    --

    -- |Returns a pointer to the file handle of low-level virtual
    -- file driver.
    --
    -- returns non-negative on success, negative otherwise.
    --
    -- > herr_t H5FDget_vfd_handle(H5FD_t *file, hid_t fapl, void**file_handle);
    foreign import ccall "H5FDget_vfd_handle" h5fd_get_vfd_handle
      :: In H5FD_t -> HId_t -> Out (Ptr a) -> IO HErr_t
    foreign import ccall "&H5FDget_vfd_handle" p_H5FDget_vfd_handle
      :: FunPtr (In H5FD_t -> HId_t -> Out (Ptr a) -> IO HErr_t)

    {-# LINE 461 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Reads 'size' bytes from 'file' beginning at address 'addr'
    -- according to the data transfer property list 'dxpl_id' (which may
    -- be the constant 'h5p_DEFAULT'). The result is written into the
    -- buffer 'buf'.
    --
    -- Returns non-negative on success.  The read result is written into
    -- the 'buf' buffer which should be allocated by the caller.
    --
    -- On failure, returns a negative value and the contents of 'buf'
    -- is undefined.
    --
    -- > herr_t H5FDread(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id,
    -- >        haddr_t addr, size_t size, void *buf/*out*/);
    foreign import ccall "H5FDread" h5fd_read
      :: In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> OutArray a -> IO HErr_t
    foreign import ccall "&H5FDread" p_H5FDread
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> OutArray a -> IO HErr_t)

    {-# LINE 476 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Writes 'size' bytes to 'file' beginning at address 'addr' according
    -- to the data transfer property list 'dxpl_id' (which may be the
    -- constant 'h5p_DEFAULT'). The bytes to be written come from the
    -- buffer 'buf'.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDwrite(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id,
    -- >        haddr_t addr, size_t size, const void *buf);
    foreign import ccall "H5FDwrite" h5fd_write
      :: In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> InArray a -> IO HErr_t
    foreign import ccall "&H5FDwrite" p_H5FDwrite
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> HId_t -> HAddr_t -> CSize -> InArray a -> IO HErr_t)

    {-# LINE 487 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Notify driver to flush all cached data.  If the driver has no
    -- flush method then nothing happens.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDflush(H5FD_t *file, hid_t dxpl_id, unsigned closing);
    foreign import ccall "H5FDflush" h5fd_flush
      :: In H5FD_t -> HId_t -> CUInt -> IO HErr_t
    foreign import ccall "&H5FDflush" p_H5FDflush
      :: FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t)

    {-# LINE 495 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Notify driver to truncate the file back to the allocated size.
    --
    -- Returns non-negative on success, negative on failure.
    --
    -- > herr_t H5FDtruncate(H5FD_t *file, hid_t dxpl_id, hbool_t closing);
    foreign import ccall "H5FDtruncate" h5fd_truncate
      :: In H5FD_t -> HId_t -> HBool_t -> IO HErr_t
    foreign import ccall "&H5FDtruncate" p_H5FDtruncate
      :: FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t)

    {-# LINE 502 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "extensible array" header blocks to 'ohdr' type file memory, since its
    -- a fair amount of work to add a new kind of file memory and they are similar
    -- enough to object headers and probably too minor to deserve their own type.
    --
    -- Map "extensible array" index blocks to 'ohdr' type file memory, since they
    -- are similar to extensible array header blocks.
    --
    -- Map "extensible array" super blocks to 'btree' type file memory, since they
    -- are similar enough to B-tree nodes.
    --
    -- Map "extensible array" data blocks & pages to 'lheap' type file memory, since
    -- they are similar enough to local heap info.

    h5fd_MEM_EARRAY_HDR :: H5F_mem_t
    h5fd_MEM_EARRAY_HDR :: H5F_mem_t
    h5fd_MEM_EARRAY_HDR = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 517 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_EARRAY_IBLOCK :: H5F_mem_t
    h5fd_MEM_EARRAY_IBLOCK = H5F_mem_t (6)

    {-# LINE 518 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_EARRAY_SBLOCK :: H5F_mem_t
    h5fd_MEM_EARRAY_SBLOCK = H5F_mem_t (2)

    {-# LINE 519 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_EARRAY_DBLOCK :: H5F_mem_t
    h5fd_MEM_EARRAY_DBLOCK = H5F_mem_t (5)

    {-# LINE 520 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_EARRAY_DBLK_PAGE :: H5F_mem_t
    h5fd_MEM_EARRAY_DBLK_PAGE = H5F_mem_t (5)

    {-# LINE 521 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Map "fixed array" header blocks to 'ohdr' type file memory, since its
    -- a fair amount of work to add a new kind of file memory and they are similar
    -- enough to object headers and probably too minor to deserve their own type.
    --
    -- Map "fixed array" data blocks & pages to 'lheap' type file memory, since
    -- they are similar enough to local heap info.

    h5fd_MEM_FARRAY_HDR :: H5F_mem_t
    h5fd_MEM_FARRAY_HDR :: H5F_mem_t
    h5fd_MEM_FARRAY_HDR = Int32 -> H5F_mem_t
    H5F_mem_t (Int32
    6)

    {-# LINE 530 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_FARRAY_DBLOCK :: H5F_mem_t
    h5fd_MEM_FARRAY_DBLOCK = H5F_mem_t (5)

    {-# LINE 531 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
    h5fd_MEM_FARRAY_DBLK_PAGE :: H5F_mem_t
    h5fd_MEM_FARRAY_DBLK_PAGE = H5F_mem_t (5)

    {-# LINE 532 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- |Defining 'H5FD_FEAT_SUPPORTS_SWMR_IO' for a VFL driver means that the
    -- driver supports the single-writer/multiple-readers I/O pattern.

    h5fd_FEAT_SUPPORTS_SWMR_IO :: forall a. Num a => a
    h5fd_FEAT_SUPPORTS_SWMR_IO = a
    4096
    h5fd_FEAT_SUPPORTS_SWMR_IO :: (Num a) => a

    {-# LINE 537 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- > herr_t H5FDlock(H5FD_t *file, hbool_t rw);
    foreign import ccall "H5FDlock" h5fd_lock
      :: In H5FD_t -> HBool_t -> IO HErr_t
    foreign import ccall "&H5FDlock" p_H5FDlock
      :: FunPtr (In H5FD_t -> HBool_t -> IO HErr_t)

    {-# LINE 540 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- > herr_t H5FDunlock(H5FD_t *file);
    foreign import ccall "H5FDunlock" h5fd_unlock
      :: In H5FD_t -> IO HErr_t
    foreign import ccall "&H5FDunlock" p_H5FDunlock
      :: FunPtr (In H5FD_t -> IO HErr_t)

    {-# LINE 543 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

    -- > haddr_t H5FDget_eof(H5FD_t *file, H5FD_mem_t type);
    foreign import ccall "H5FDget_eof" h5fd_get_eof
      :: In H5FD_t -> H5FD_mem_t -> IO HAddr_t
    foreign import ccall "&H5FDget_eof" p_H5FDget_eof
      :: FunPtr (In H5FD_t -> H5FD_mem_t -> IO HAddr_t)

    {-# LINE 546 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}