{-# LINE 1 "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 25 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


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

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


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

-- |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.

{-# LINE 54 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 55 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 58 "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.

{-# LINE 62 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 63 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

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

-- |Map "fractal heap" direct blocks to 'lheap' type file memory, since they
-- will be replacing local heaps.

{-# LINE 70 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 71 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 74 "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.

{-# LINE 78 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 79 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 82 "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.

{-# LINE 87 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 88 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 91 "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.

{-# LINE 95 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 96 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 99 "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.

{-# LINE 105 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 106 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

{-# LINE 109 "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.

{-# LINE 113 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
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 114 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

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


{-# LINE 119 "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 133 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
h5fd_MEM_EARRAY_IBLOCK :: H5F_mem_t
h5fd_MEM_EARRAY_IBLOCK = H5F_mem_t (6)

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

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

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

{-# LINE 137 "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 147 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
h5fd_MEM_FARRAY_DBLOCK :: H5F_mem_t
h5fd_MEM_FARRAY_DBLOCK = H5F_mem_t (5)

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

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


{-# LINE 151 "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 164 "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 168 "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 172 "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 177 "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 191 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
h5fd_FEAT_ACCUMULATE_METADATA_WRITE = 2
h5fd_FEAT_ACCUMULATE_METADATA_WRITE :: (Num a) => a

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

{-# LINE 193 "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 202 "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 207 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


{-# LINE 209 "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 215 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


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


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


{-# LINE 228 "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 233 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


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


{-# LINE 237 "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 242 "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 247 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


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


{-# LINE 251 "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 256 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


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

-- |Class information for each file driver

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


{-# LINE 315 "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
0
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
8
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
16
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
24
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
32
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
40
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 = Ptr H5FD_class_t
-> Int
-> Ptr (FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t))
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
p Int
48
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 :: Ptr H5FD_class_t -> Ptr CSize
p'H5FD_class_t'fapl_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
56
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 = Ptr H5FD_class_t -> Int -> Ptr (FunPtr (In H5FD_t -> IO (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
p Int
64
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
72
p'H5FD_class_t'fapl_copy :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
p'H5FD_class_t'fapl_free :: Ptr H5FD_class_t -> Ptr (FunPtr (Ptr () -> IO HErr_t))
p'H5FD_class_t'fapl_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
80
h5fd_FILE_IMAGE_OP_NO_OP :: H5FD_file_image_op_t
p'H5FD_class_t'fapl_free :: Ptr (H5FD_class_t) -> Ptr (FunPtr (Ptr () -> IO HErr_t))
p'H5FD_class_t'dxpl_size p = plusPtr p 88
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 = plusPtr p 96
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 = plusPtr p 104
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
112
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 p = plusPtr p 120
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
128
p'H5FD_t'base_addr :: Ptr H5FD_t -> Ptr HAddr_t
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
136
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
144
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
152
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
160
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
168
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
176
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 :: Ptr H5FD_class_t
-> Ptr (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
p'H5FD_class_t'get_eof 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
184
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 :: Ptr H5FD_class_t
-> Ptr (FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t))
p'H5FD_class_t'get_handle Ptr H5FD_class_t
p = Ptr H5FD_class_t
-> Int
-> Ptr (FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t))
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
p Int
192
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 :: Ptr H5FD_class_t
-> Ptr
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> OutArray ()
         -> IO HErr_t))
p'H5FD_class_t'read Ptr H5FD_class_t
p = Ptr H5FD_class_t
-> Int
-> Ptr
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> OutArray ()
         -> IO HErr_t))
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
p Int
200
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 :: Ptr H5FD_class_t
-> Ptr
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> InArray ()
         -> IO HErr_t))
p'H5FD_class_t'write Ptr H5FD_class_t
p = Ptr H5FD_class_t
-> Int
-> Ptr
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> InArray ()
         -> IO HErr_t))
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
p Int
208
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 p = plusPtr p 216
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 p = plusPtr p 224
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 p = plusPtr p 232
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 240
p'H5FD_class_t'unlock :: Ptr (H5FD_class_t) -> Ptr (FunPtr (In H5FD_t -> IO HErr_t))
p'H5FD_class_t'fl_map :: Ptr H5FD_class_t -> Ptr H5F_mem_t
p'H5FD_class_t'fl_map Ptr H5FD_class_t
p = plusPtr p 248
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
280
  alignment :: H5FD_class_t -> Int
alignment H5FD_class_t
_ = Int
8
  peek _p = do
    v0 <- peekByteOff _p 0
    v1 <- peekByteOff _p 8
    v2 <- peekByteOff _p 16
    v3 <- peekByteOff _p 24
    v4 <- peekByteOff _p 32
    v5 <- peekByteOff _p 40
    v6 <- peekByteOff _p 48
    v7 <- peekByteOff _p 56
    v8 <- peekByteOff _p 64
    v9 <- peekByteOff _p 72
    v10 <- peekByteOff _p 80
    v11 <- peekByteOff _p 88
    v12 <- peekByteOff _p 96
    v13 <- peekByteOff _p 104
    v14 <- peekByteOff _p 112
    v15 <- peekByteOff _p 120
    v16 <- peekByteOff _p 128
    v17 <- peekByteOff _p 136
    v18 <- peekByteOff _p 144
    v19 <- peekByteOff _p 152
    v20 <- peekByteOff _p 160
    v21 <- peekByteOff _p 168
    v22 <- peekByteOff _p 176
    v23 <- peekByteOff _p 184
    v24 <- peekByteOff _p 192
    v25 <- peekByteOff _p 200
    v26 <- peekByteOff _p 208
    v27 <- peekByteOff _p 216
    v28 <- peekByteOff _p 224
    v29 <- peekByteOff _p 232
    v30 <- peekByteOff _p 240
    v31 <- let s31 = div 28 $ sizeOf $ (undefined :: H5FD_mem_t) in peekArray s31 (plusPtr _p 248)
    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 0 v0
    pokeByteOff _p 8 v1
    pokeByteOff _p 16 v2
    pokeByteOff _p 24 v3
    pokeByteOff _p 32 v4
    pokeByteOff _p 40 v5
    pokeByteOff _p 48 v6
    pokeByteOff _p 56 v7
    pokeByteOff _p 64 v8
    pokeByteOff _p 72 v9
    pokeByteOff _p 80 v10
    pokeByteOff _p 88 v11
    pokeByteOff _p 96 v12
    pokeByteOff _p 104 v13
    pokeByteOff _p 112 v14
    pokeByteOff _p 120 v15
    pokeByteOff _p 128 v16
    pokeByteOff _p 136 v17
    pokeByteOff _p 144 v18
    pokeByteOff _p 152 v19
    pokeByteOff _p 160 v20
    pokeByteOff _p 168 v21
    pokeByteOff _p 176 v22
    pokeByteOff _p 184 v23
    pokeByteOff _p 192 v24
    pokeByteOff _p 200 v25
    pokeByteOff _p 208 v26
    pokeByteOff _p 216 v27
    pokeByteOff _p 224 v28
    pokeByteOff _p 232 v29
    pokeByteOff _p 240 v30
    let s31 = div 28 $ sizeOf $ (undefined :: H5FD_mem_t)
    pokeArray (plusPtr _p 248) (take s31 v31)
    return ()

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


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

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

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

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

{-# LINE 323 "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 324 "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 329 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

-- |driver ID for this file

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

-- |constant class info

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

-- |File 'serial' number

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

-- |VFL Driver feature Flags

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

-- |For this file, overrides class

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


{-# LINE 346 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}
-- |Base address for HDF5 data w/in file

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

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


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

-- Space allocation management fields

-- |Threshold for alignment

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

{-# LINE 362 "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 363 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


{-# LINE 365 "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 368 "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 370 "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 371 "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 372 "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 373 "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 374 "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 375 "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 376 "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 377 "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;


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

-- |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 410 "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 420 "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 472 "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 483 "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 499 "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 507 "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 540 "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 553 "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 559 "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 578 "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'
--

{-# LINE 594 "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 596 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

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

-- |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 608 "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 623 "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 634 "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 642 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}


{-# LINE 644 "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 650 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

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


{-# LINE 653 "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 655 "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 658 "src/Bindings/HDF5/Raw/H5FD.hsc" #-}

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