{-# 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
    CString
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
    HAddr_t
v1 <- Ptr H5FD_class_t -> Int -> IO HAddr_t
forall b. Ptr b -> Int -> IO HAddr_t
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
16
    H5F_close_degree_t
v2 <- Ptr H5FD_class_t -> Int -> IO H5F_close_degree_t
forall b. Ptr b -> Int -> IO H5F_close_degree_t
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
24
    FunPtr (IO HErr_t)
v3 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (IO HErr_t))
forall b. Ptr b -> Int -> IO (FunPtr (IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
32
    FunPtr (In H5FD_t -> IO HSize_t)
v4 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (In H5FD_t -> IO HSize_t))
forall b. Ptr b -> Int -> IO (FunPtr (In H5FD_t -> IO HSize_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
40
    FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t)
v5 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
48
    FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t)
v6 <- Ptr H5FD_class_t
-> Int
-> IO (FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO (FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
56
    CSize
v7 <- Ptr H5FD_class_t -> Int -> IO CSize
forall b. Ptr b -> Int -> IO CSize
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
64
    FunPtr (In H5FD_t -> IO (Ptr ()))
v8 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (In H5FD_t -> IO (Ptr ())))
forall b. Ptr b -> Int -> IO (FunPtr (In H5FD_t -> IO (Ptr ())))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
72
    FunPtr (Ptr () -> IO (Ptr ()))
v9 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (Ptr () -> IO (Ptr ())))
forall b. Ptr b -> Int -> IO (FunPtr (Ptr () -> IO (Ptr ())))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
80
    FunPtr (Ptr () -> IO HErr_t)
v10 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (Ptr () -> IO HErr_t))
forall b. Ptr b -> Int -> IO (FunPtr (Ptr () -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
88
    CSize
v11 <- Ptr H5FD_class_t -> Int -> IO CSize
forall b. Ptr b -> Int -> IO CSize
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
96
    FunPtr (Ptr () -> IO (Ptr ()))
v12 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (Ptr () -> IO (Ptr ())))
forall b. Ptr b -> Int -> IO (FunPtr (Ptr () -> IO (Ptr ())))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
104
    FunPtr (Ptr () -> IO HErr_t)
v13 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (Ptr () -> IO HErr_t))
forall b. Ptr b -> Int -> IO (FunPtr (Ptr () -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
112
    FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t))
v14 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t)))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
120
    FunPtr (In H5FD_t -> IO HErr_t)
v15 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (In H5FD_t -> IO HErr_t))
forall b. Ptr b -> Int -> IO (FunPtr (In H5FD_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
128
    FunPtr (In H5FD_t -> In H5FD_t -> IO CInt)
v16 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> In H5FD_t -> IO CInt))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> In H5FD_t -> IO CInt))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
136
    FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t)
v17 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
144
    FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t)
v18 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t))
forall b.
Ptr b
-> Int -> IO (FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
152
    FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t)
v19 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
160
    FunPtr
  (In H5FD_t
   -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t)
v20 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
168
    FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
v21 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
176
    FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t)
v22 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
184
    FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
v23 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
192
    FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t)
v24 <- Ptr H5FD_class_t
-> Int
-> IO (FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO (FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
200
    FunPtr
  (In H5FD_t
   -> H5F_mem_t
   -> HId_t
   -> HAddr_t
   -> CSize
   -> OutArray ()
   -> IO HErr_t)
v25 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> OutArray ()
         -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> OutArray ()
         -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
208
    FunPtr
  (In H5FD_t
   -> H5F_mem_t
   -> HId_t
   -> HAddr_t
   -> CSize
   -> InArray ()
   -> IO HErr_t)
v26 <- Ptr H5FD_class_t
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> InArray ()
         -> IO HErr_t))
forall b.
Ptr b
-> Int
-> IO
     (FunPtr
        (In H5FD_t
         -> H5F_mem_t
         -> HId_t
         -> HAddr_t
         -> CSize
         -> InArray ()
         -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
216
    FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t)
v27 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t))
forall b.
Ptr b
-> Int -> IO (FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
256
    FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t)
v28 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t))
forall b.
Ptr b
-> Int -> IO (FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
264
    FunPtr (In H5FD_t -> HBool_t -> IO HErr_t)
v29 <- Ptr H5FD_class_t
-> Int -> IO (FunPtr (In H5FD_t -> HBool_t -> IO HErr_t))
forall b.
Ptr b -> Int -> IO (FunPtr (In H5FD_t -> HBool_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
272
    FunPtr (In H5FD_t -> IO HErr_t)
v30 <- Ptr H5FD_class_t -> Int -> IO (FunPtr (In H5FD_t -> IO HErr_t))
forall b. Ptr b -> Int -> IO (FunPtr (In H5FD_t -> IO HErr_t))
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr H5FD_class_t
_p Int
280
    [H5F_mem_t]
v31 <- let s31 :: Int
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 Int -> Ptr H5F_mem_t -> IO [H5F_mem_t]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
s31 (Ptr H5FD_class_t -> Int -> Ptr H5F_mem_t
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5FD_class_t
_p Int
304)
    H5FD_class_t -> IO H5FD_class_t
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (H5FD_class_t -> IO H5FD_class_t)
-> H5FD_class_t -> IO H5FD_class_t
forall a b. (a -> b) -> a -> b
$ CString
-> HAddr_t
-> H5F_close_degree_t
-> FunPtr (IO HErr_t)
-> FunPtr (In H5FD_t -> IO HSize_t)
-> FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t)
-> FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t)
-> CSize
-> FunPtr (In H5FD_t -> IO (Ptr ()))
-> FunPtr (Ptr () -> IO (Ptr ()))
-> FunPtr (Ptr () -> IO HErr_t)
-> CSize
-> FunPtr (Ptr () -> IO (Ptr ()))
-> FunPtr (Ptr () -> IO HErr_t)
-> FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t))
-> FunPtr (In H5FD_t -> IO HErr_t)
-> FunPtr (In H5FD_t -> In H5FD_t -> IO CInt)
-> FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t)
-> FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t)
-> FunPtr
     (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t)
-> FunPtr
     (In H5FD_t
      -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t)
-> FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
-> FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t)
-> FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
-> FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t)
-> FunPtr
     (In H5FD_t
      -> H5F_mem_t
      -> HId_t
      -> HAddr_t
      -> CSize
      -> OutArray ()
      -> IO HErr_t)
-> FunPtr
     (In H5FD_t
      -> H5F_mem_t
      -> HId_t
      -> HAddr_t
      -> CSize
      -> InArray ()
      -> IO HErr_t)
-> FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t)
-> FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t)
-> FunPtr (In H5FD_t -> HBool_t -> IO HErr_t)
-> FunPtr (In H5FD_t -> IO HErr_t)
-> [H5F_mem_t]
-> H5FD_class_t
H5FD_class_t CString
v0 HAddr_t
v1 H5F_close_degree_t
v2 FunPtr (IO HErr_t)
v3 FunPtr (In H5FD_t -> IO HSize_t)
v4 FunPtr (In H5FD_t -> OutArray CChar -> Out CUChar -> IO HErr_t)
v5 FunPtr (In H5FD_t -> CString -> In CUChar -> IO HErr_t)
v6 CSize
v7 FunPtr (In H5FD_t -> IO (Ptr ()))
v8 FunPtr (Ptr () -> IO (Ptr ()))
v9 FunPtr (Ptr () -> IO HErr_t)
v10 CSize
v11 FunPtr (Ptr () -> IO (Ptr ()))
v12 FunPtr (Ptr () -> IO HErr_t)
v13 FunPtr (CString -> CUInt -> HId_t -> HAddr_t -> IO (Ptr H5FD_t))
v14 FunPtr (In H5FD_t -> IO HErr_t)
v15 FunPtr (In H5FD_t -> In H5FD_t -> IO CInt)
v16 FunPtr (In H5FD_t -> Ptr CULong -> IO HErr_t)
v17 FunPtr (In H5FD_t -> Out H5F_mem_t -> IO HErr_t)
v18 FunPtr (In H5FD_t -> H5F_mem_t -> HId_t -> HSize_t -> IO HAddr_t)
v19 FunPtr
  (In H5FD_t
   -> H5F_mem_t -> HId_t -> HAddr_t -> HSize_t -> IO HErr_t)
v20 FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
v21 FunPtr (In H5FD_t -> H5F_mem_t -> HAddr_t)
v22 FunPtr (In H5FD_t -> H5F_mem_t -> IO HAddr_t)
v23 FunPtr (In H5FD_t -> HId_t -> Out (Ptr ()) -> IO HErr_t)
v24 FunPtr
  (In H5FD_t
   -> H5F_mem_t
   -> HId_t
   -> HAddr_t
   -> CSize
   -> OutArray ()
   -> IO HErr_t)
v25 FunPtr
  (In H5FD_t
   -> H5F_mem_t
   -> HId_t
   -> HAddr_t
   -> CSize
   -> InArray ()
   -> IO HErr_t)
v26 FunPtr (In H5FD_t -> HId_t -> CUInt -> IO HErr_t)
v27 FunPtr (In H5FD_t -> HId_t -> HBool_t -> IO HErr_t)
v28 FunPtr (In H5FD_t -> HBool_t -> IO HErr_t)
v29 FunPtr (In H5FD_t -> IO HErr_t)
v30 [H5F_mem_t]
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" #-}