{-# LINE 1 "src/Bindings/HDF5/Raw/H5.hsc" #-}
module Bindings.HDF5.Raw.H5 where



import Data.Bits
import Data.Int
import Data.Version
import Data.Word
import Foreign.C.Types
import Foreign.Ptr
import Foreign.Storable

import Foreign.Ptr.Conventions

-- *Version numbers

-- |For major interface/format changes
h5_VERS_MAJOR :: forall a. Num a => a
h5_VERS_MAJOR = a
1
h5_VERS_MAJOR :: (Num a) => a

{-# LINE 19 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |For minor interface/format changes
h5_VERS_MINOR = 14
h5_VERS_MINOR :: (Num a) => a

{-# LINE 22 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |For tweaks, bug-fixes, or development
h5_VERS_RELEASE = 5
h5_VERS_RELEASE :: (Num a) => a

{-# LINE 25 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |For pre-releases like snap0
h5_VERS_SUBRELEASE :: String
h5_VERS_SUBRELEASE :: String
h5_VERS_SUBRELEASE = String
""

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

-- |'h5_VERS_MAJOR', et al., wrapped up as a 'Version'
vers :: Version
vers :: Version
vers = [Int] -> [String] -> Version
Version
    [ Int
forall a. Num a => a
h5_VERS_MAJOR
    , Int
forall a. Num a => a
h5_VERS_MINOR
    , Int
forall a. Num a => a
h5_VERS_RELEASE
    ]
    ((String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not(Bool -> Bool) -> (String -> Bool) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) [ String
h5_VERS_SUBRELEASE ])

-- |Full version string
h5_VERS_INFO :: String
h5_VERS_INFO :: String
h5_VERS_INFO = String
"HDF5 library version: 1.14.5"

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

-- |Check that the HDF5 library that is linked with the current executable is
-- the same version that these bindings were compiled against.  Returns 0 on
-- success, calls abort() on failure.
foreign import ccall "inline_H5check" h5_check
  :: HErr_t

{-# LINE 45 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- * Types and constants

-- |Status return values.  Failed integer functions in HDF5 result almost
-- always in a negative value (unsigned failing functions sometimes return
-- zero for failure) while successfull return is non-negative (often zero).
-- The negative failure value is most commonly -1, but don't bet on it.  The
-- proper way to detect failure is something like:
--
-- @
-- if((dset = H5Dopen2(file, name)) < 0)
--    fprintf(stderr, "unable to open the requested dataset\n");
-- @
newtype HErr_t = HErr_t Int32 deriving (Ptr HErr_t -> IO HErr_t
Ptr HErr_t -> Int -> IO HErr_t
Ptr HErr_t -> Int -> HErr_t -> IO ()
Ptr HErr_t -> HErr_t -> IO ()
HErr_t -> Int
(HErr_t -> Int)
-> (HErr_t -> Int)
-> (Ptr HErr_t -> Int -> IO HErr_t)
-> (Ptr HErr_t -> Int -> HErr_t -> IO ())
-> (forall b. Ptr b -> Int -> IO HErr_t)
-> (forall b. Ptr b -> Int -> HErr_t -> IO ())
-> (Ptr HErr_t -> IO HErr_t)
-> (Ptr HErr_t -> HErr_t -> IO ())
-> Storable HErr_t
forall b. Ptr b -> Int -> IO HErr_t
forall b. Ptr b -> Int -> HErr_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: HErr_t -> Int
sizeOf :: HErr_t -> Int
$calignment :: HErr_t -> Int
alignment :: HErr_t -> Int
$cpeekElemOff :: Ptr HErr_t -> Int -> IO HErr_t
peekElemOff :: Ptr HErr_t -> Int -> IO HErr_t
$cpokeElemOff :: Ptr HErr_t -> Int -> HErr_t -> IO ()
pokeElemOff :: Ptr HErr_t -> Int -> HErr_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO HErr_t
peekByteOff :: forall b. Ptr b -> Int -> IO HErr_t
$cpokeByteOff :: forall b. Ptr b -> Int -> HErr_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> HErr_t -> IO ()
$cpeek :: Ptr HErr_t -> IO HErr_t
peek :: Ptr HErr_t -> IO HErr_t
$cpoke :: Ptr HErr_t -> HErr_t -> IO ()
poke :: Ptr HErr_t -> HErr_t -> IO ()
Storable, Int -> HErr_t -> ShowS
[HErr_t] -> ShowS
HErr_t -> String
(Int -> HErr_t -> ShowS)
-> (HErr_t -> String) -> ([HErr_t] -> ShowS) -> Show HErr_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HErr_t -> ShowS
showsPrec :: Int -> HErr_t -> ShowS
$cshow :: HErr_t -> String
show :: HErr_t -> String
$cshowList :: [HErr_t] -> ShowS
showList :: [HErr_t] -> ShowS
Show, HErr_t -> HErr_t -> Bool
(HErr_t -> HErr_t -> Bool)
-> (HErr_t -> HErr_t -> Bool) -> Eq HErr_t
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HErr_t -> HErr_t -> Bool
== :: HErr_t -> HErr_t -> Bool
$c/= :: HErr_t -> HErr_t -> Bool
/= :: HErr_t -> HErr_t -> Bool
Eq, Eq HErr_t
Eq HErr_t =>
(HErr_t -> HErr_t -> Ordering)
-> (HErr_t -> HErr_t -> Bool)
-> (HErr_t -> HErr_t -> Bool)
-> (HErr_t -> HErr_t -> Bool)
-> (HErr_t -> HErr_t -> Bool)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> Ord HErr_t
HErr_t -> HErr_t -> Bool
HErr_t -> HErr_t -> Ordering
HErr_t -> HErr_t -> HErr_t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HErr_t -> HErr_t -> Ordering
compare :: HErr_t -> HErr_t -> Ordering
$c< :: HErr_t -> HErr_t -> Bool
< :: HErr_t -> HErr_t -> Bool
$c<= :: HErr_t -> HErr_t -> Bool
<= :: HErr_t -> HErr_t -> Bool
$c> :: HErr_t -> HErr_t -> Bool
> :: HErr_t -> HErr_t -> Bool
$c>= :: HErr_t -> HErr_t -> Bool
>= :: HErr_t -> HErr_t -> Bool
$cmax :: HErr_t -> HErr_t -> HErr_t
max :: HErr_t -> HErr_t -> HErr_t
$cmin :: HErr_t -> HErr_t -> HErr_t
min :: HErr_t -> HErr_t -> HErr_t
Ord, Integer -> HErr_t
HErr_t -> HErr_t
HErr_t -> HErr_t -> HErr_t
(HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t)
-> (HErr_t -> HErr_t)
-> (HErr_t -> HErr_t)
-> (Integer -> HErr_t)
-> Num HErr_t
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: HErr_t -> HErr_t -> HErr_t
+ :: HErr_t -> HErr_t -> HErr_t
$c- :: HErr_t -> HErr_t -> HErr_t
- :: HErr_t -> HErr_t -> HErr_t
$c* :: HErr_t -> HErr_t -> HErr_t
* :: HErr_t -> HErr_t -> HErr_t
$cnegate :: HErr_t -> HErr_t
negate :: HErr_t -> HErr_t
$cabs :: HErr_t -> HErr_t
abs :: HErr_t -> HErr_t
$csignum :: HErr_t -> HErr_t
signum :: HErr_t -> HErr_t
$cfromInteger :: Integer -> HErr_t
fromInteger :: Integer -> HErr_t
Num, Num HErr_t
Ord HErr_t
(Num HErr_t, Ord HErr_t) => (HErr_t -> Rational) -> Real HErr_t
HErr_t -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: HErr_t -> Rational
toRational :: HErr_t -> Rational
Real, Eq HErr_t
HErr_t
Eq HErr_t =>
(HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> HErr_t
-> (Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> Bool)
-> (HErr_t -> Maybe Int)
-> (HErr_t -> Int)
-> (HErr_t -> Bool)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int -> HErr_t)
-> (HErr_t -> Int)
-> Bits HErr_t
Int -> HErr_t
HErr_t -> Bool
HErr_t -> Int
HErr_t -> Maybe Int
HErr_t -> HErr_t
HErr_t -> Int -> Bool
HErr_t -> Int -> HErr_t
HErr_t -> HErr_t -> HErr_t
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: HErr_t -> HErr_t -> HErr_t
.&. :: HErr_t -> HErr_t -> HErr_t
$c.|. :: HErr_t -> HErr_t -> HErr_t
.|. :: HErr_t -> HErr_t -> HErr_t
$cxor :: HErr_t -> HErr_t -> HErr_t
xor :: HErr_t -> HErr_t -> HErr_t
$ccomplement :: HErr_t -> HErr_t
complement :: HErr_t -> HErr_t
$cshift :: HErr_t -> Int -> HErr_t
shift :: HErr_t -> Int -> HErr_t
$crotate :: HErr_t -> Int -> HErr_t
rotate :: HErr_t -> Int -> HErr_t
$czeroBits :: HErr_t
zeroBits :: HErr_t
$cbit :: Int -> HErr_t
bit :: Int -> HErr_t
$csetBit :: HErr_t -> Int -> HErr_t
setBit :: HErr_t -> Int -> HErr_t
$cclearBit :: HErr_t -> Int -> HErr_t
clearBit :: HErr_t -> Int -> HErr_t
$ccomplementBit :: HErr_t -> Int -> HErr_t
complementBit :: HErr_t -> Int -> HErr_t
$ctestBit :: HErr_t -> Int -> Bool
testBit :: HErr_t -> Int -> Bool
$cbitSizeMaybe :: HErr_t -> Maybe Int
bitSizeMaybe :: HErr_t -> Maybe Int
$cbitSize :: HErr_t -> Int
bitSize :: HErr_t -> Int
$cisSigned :: HErr_t -> Bool
isSigned :: HErr_t -> Bool
$cshiftL :: HErr_t -> Int -> HErr_t
shiftL :: HErr_t -> Int -> HErr_t
$cunsafeShiftL :: HErr_t -> Int -> HErr_t
unsafeShiftL :: HErr_t -> Int -> HErr_t
$cshiftR :: HErr_t -> Int -> HErr_t
shiftR :: HErr_t -> Int -> HErr_t
$cunsafeShiftR :: HErr_t -> Int -> HErr_t
unsafeShiftR :: HErr_t -> Int -> HErr_t
$crotateL :: HErr_t -> Int -> HErr_t
rotateL :: HErr_t -> Int -> HErr_t
$crotateR :: HErr_t -> Int -> HErr_t
rotateR :: HErr_t -> Int -> HErr_t
$cpopCount :: HErr_t -> Int
popCount :: HErr_t -> Int
Bits, Int -> HErr_t
HErr_t -> Int
HErr_t -> [HErr_t]
HErr_t -> HErr_t
HErr_t -> HErr_t -> [HErr_t]
HErr_t -> HErr_t -> HErr_t -> [HErr_t]
(HErr_t -> HErr_t)
-> (HErr_t -> HErr_t)
-> (Int -> HErr_t)
-> (HErr_t -> Int)
-> (HErr_t -> [HErr_t])
-> (HErr_t -> HErr_t -> [HErr_t])
-> (HErr_t -> HErr_t -> [HErr_t])
-> (HErr_t -> HErr_t -> HErr_t -> [HErr_t])
-> Enum HErr_t
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HErr_t -> HErr_t
succ :: HErr_t -> HErr_t
$cpred :: HErr_t -> HErr_t
pred :: HErr_t -> HErr_t
$ctoEnum :: Int -> HErr_t
toEnum :: Int -> HErr_t
$cfromEnum :: HErr_t -> Int
fromEnum :: HErr_t -> Int
$cenumFrom :: HErr_t -> [HErr_t]
enumFrom :: HErr_t -> [HErr_t]
$cenumFromThen :: HErr_t -> HErr_t -> [HErr_t]
enumFromThen :: HErr_t -> HErr_t -> [HErr_t]
$cenumFromTo :: HErr_t -> HErr_t -> [HErr_t]
enumFromTo :: HErr_t -> HErr_t -> [HErr_t]
$cenumFromThenTo :: HErr_t -> HErr_t -> HErr_t -> [HErr_t]
enumFromThenTo :: HErr_t -> HErr_t -> HErr_t -> [HErr_t]
Enum, HErr_t
HErr_t -> HErr_t -> Bounded HErr_t
forall a. a -> a -> Bounded a
$cminBound :: HErr_t
minBound :: HErr_t
$cmaxBound :: HErr_t
maxBound :: HErr_t
Bounded, Enum HErr_t
Real HErr_t
(Real HErr_t, Enum HErr_t) =>
(HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> HErr_t)
-> (HErr_t -> HErr_t -> (HErr_t, HErr_t))
-> (HErr_t -> HErr_t -> (HErr_t, HErr_t))
-> (HErr_t -> Integer)
-> Integral HErr_t
HErr_t -> Integer
HErr_t -> HErr_t -> (HErr_t, HErr_t)
HErr_t -> HErr_t -> HErr_t
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: HErr_t -> HErr_t -> HErr_t
quot :: HErr_t -> HErr_t -> HErr_t
$crem :: HErr_t -> HErr_t -> HErr_t
rem :: HErr_t -> HErr_t -> HErr_t
$cdiv :: HErr_t -> HErr_t -> HErr_t
div :: HErr_t -> HErr_t -> HErr_t
$cmod :: HErr_t -> HErr_t -> HErr_t
mod :: HErr_t -> HErr_t -> HErr_t
$cquotRem :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
quotRem :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
$cdivMod :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
divMod :: HErr_t -> HErr_t -> (HErr_t, HErr_t)
$ctoInteger :: HErr_t -> Integer
toInteger :: HErr_t -> Integer
Integral)

{-# LINE 59 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Boolean type.  Successful return values are zero (false) or positive
-- (true). The typical true value is 1 but don't bet on it.  Boolean
-- functions cannot fail.  Functions that return `htri_t' however return zero
-- (false), positive (true), or negative (failure). The proper way to test
-- for truth from a htri_t function is:
--
-- @
--  if ((retval = H5Tcommitted(type))>0) {
--    printf("data type is committed\n");
--  } else if (!retval) {
--    printf("data type is not committed\n");
--  } else {
--    printf("error determining whether data type is committed\n");
--  }
-- @
newtype HBool_t = HBool_t Word8 deriving (Ptr HBool_t -> IO HBool_t
Ptr HBool_t -> Int -> IO HBool_t
Ptr HBool_t -> Int -> HBool_t -> IO ()
Ptr HBool_t -> HBool_t -> IO ()
HBool_t -> Int
(HBool_t -> Int)
-> (HBool_t -> Int)
-> (Ptr HBool_t -> Int -> IO HBool_t)
-> (Ptr HBool_t -> Int -> HBool_t -> IO ())
-> (forall b. Ptr b -> Int -> IO HBool_t)
-> (forall b. Ptr b -> Int -> HBool_t -> IO ())
-> (Ptr HBool_t -> IO HBool_t)
-> (Ptr HBool_t -> HBool_t -> IO ())
-> Storable HBool_t
forall b. Ptr b -> Int -> IO HBool_t
forall b. Ptr b -> Int -> HBool_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: HBool_t -> Int
sizeOf :: HBool_t -> Int
$calignment :: HBool_t -> Int
alignment :: HBool_t -> Int
$cpeekElemOff :: Ptr HBool_t -> Int -> IO HBool_t
peekElemOff :: Ptr HBool_t -> Int -> IO HBool_t
$cpokeElemOff :: Ptr HBool_t -> Int -> HBool_t -> IO ()
pokeElemOff :: Ptr HBool_t -> Int -> HBool_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO HBool_t
peekByteOff :: forall b. Ptr b -> Int -> IO HBool_t
$cpokeByteOff :: forall b. Ptr b -> Int -> HBool_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> HBool_t -> IO ()
$cpeek :: Ptr HBool_t -> IO HBool_t
peek :: Ptr HBool_t -> IO HBool_t
$cpoke :: Ptr HBool_t -> HBool_t -> IO ()
poke :: Ptr HBool_t -> HBool_t -> IO ()
Storable, Int -> HBool_t -> ShowS
[HBool_t] -> ShowS
HBool_t -> String
(Int -> HBool_t -> ShowS)
-> (HBool_t -> String) -> ([HBool_t] -> ShowS) -> Show HBool_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HBool_t -> ShowS
showsPrec :: Int -> HBool_t -> ShowS
$cshow :: HBool_t -> String
show :: HBool_t -> String
$cshowList :: [HBool_t] -> ShowS
showList :: [HBool_t] -> ShowS
Show)

{-# LINE 76 "src/Bindings/HDF5/Raw/H5.hsc" #-}

instance Eq HBool_t where
    HBool_t x == HBool_t y
        = (x /= 0) == (y /= 0)

newtype HTri_t = HTri_t Int32 deriving (Ptr HTri_t -> IO HTri_t
Ptr HTri_t -> Int -> IO HTri_t
Ptr HTri_t -> Int -> HTri_t -> IO ()
Ptr HTri_t -> HTri_t -> IO ()
HTri_t -> Int
(HTri_t -> Int)
-> (HTri_t -> Int)
-> (Ptr HTri_t -> Int -> IO HTri_t)
-> (Ptr HTri_t -> Int -> HTri_t -> IO ())
-> (forall b. Ptr b -> Int -> IO HTri_t)
-> (forall b. Ptr b -> Int -> HTri_t -> IO ())
-> (Ptr HTri_t -> IO HTri_t)
-> (Ptr HTri_t -> HTri_t -> IO ())
-> Storable HTri_t
forall b. Ptr b -> Int -> IO HTri_t
forall b. Ptr b -> Int -> HTri_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: HTri_t -> Int
sizeOf :: HTri_t -> Int
$calignment :: HTri_t -> Int
alignment :: HTri_t -> Int
$cpeekElemOff :: Ptr HTri_t -> Int -> IO HTri_t
peekElemOff :: Ptr HTri_t -> Int -> IO HTri_t
$cpokeElemOff :: Ptr HTri_t -> Int -> HTri_t -> IO ()
pokeElemOff :: Ptr HTri_t -> Int -> HTri_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO HTri_t
peekByteOff :: forall b. Ptr b -> Int -> IO HTri_t
$cpokeByteOff :: forall b. Ptr b -> Int -> HTri_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> HTri_t -> IO ()
$cpeek :: Ptr HTri_t -> IO HTri_t
peek :: Ptr HTri_t -> IO HTri_t
$cpoke :: Ptr HTri_t -> HTri_t -> IO ()
poke :: Ptr HTri_t -> HTri_t -> IO ()
Storable, Int -> HTri_t -> ShowS
[HTri_t] -> ShowS
HTri_t -> String
(Int -> HTri_t -> ShowS)
-> (HTri_t -> String) -> ([HTri_t] -> ShowS) -> Show HTri_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HTri_t -> ShowS
showsPrec :: Int -> HTri_t -> ShowS
$cshow :: HTri_t -> String
show :: HTri_t -> String
$cshowList :: [HTri_t] -> ShowS
showList :: [HTri_t] -> ShowS
Show)

{-# LINE 82 "src/Bindings/HDF5/Raw/H5.hsc" #-}

instance Eq HTri_t where
    HTri_t x == HTri_t y
        = compare x 0 == compare y 0

-- |C signed size type.  This is a semi-standard POSIX type that isn't in
-- the "Foreign.C.Types" module.  It is in "System.Posix.Types", but I'm not
-- sure whether that module is available on all platforms.
newtype CSSize = CSSize Int64 deriving (Ptr CSSize -> IO CSSize
Ptr CSSize -> Int -> IO CSSize
Ptr CSSize -> Int -> CSSize -> IO ()
Ptr CSSize -> CSSize -> IO ()
CSSize -> Int
(CSSize -> Int)
-> (CSSize -> Int)
-> (Ptr CSSize -> Int -> IO CSSize)
-> (Ptr CSSize -> Int -> CSSize -> IO ())
-> (forall b. Ptr b -> Int -> IO CSSize)
-> (forall b. Ptr b -> Int -> CSSize -> IO ())
-> (Ptr CSSize -> IO CSSize)
-> (Ptr CSSize -> CSSize -> IO ())
-> Storable CSSize
forall b. Ptr b -> Int -> IO CSSize
forall b. Ptr b -> Int -> CSSize -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: CSSize -> Int
sizeOf :: CSSize -> Int
$calignment :: CSSize -> Int
alignment :: CSSize -> Int
$cpeekElemOff :: Ptr CSSize -> Int -> IO CSSize
peekElemOff :: Ptr CSSize -> Int -> IO CSSize
$cpokeElemOff :: Ptr CSSize -> Int -> CSSize -> IO ()
pokeElemOff :: Ptr CSSize -> Int -> CSSize -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO CSSize
peekByteOff :: forall b. Ptr b -> Int -> IO CSSize
$cpokeByteOff :: forall b. Ptr b -> Int -> CSSize -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> CSSize -> IO ()
$cpeek :: Ptr CSSize -> IO CSSize
peek :: Ptr CSSize -> IO CSSize
$cpoke :: Ptr CSSize -> CSSize -> IO ()
poke :: Ptr CSSize -> CSSize -> IO ()
Storable, Int -> CSSize -> ShowS
[CSSize] -> ShowS
CSSize -> String
(Int -> CSSize -> ShowS)
-> (CSSize -> String) -> ([CSSize] -> ShowS) -> Show CSSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CSSize -> ShowS
showsPrec :: Int -> CSSize -> ShowS
$cshow :: CSSize -> String
show :: CSSize -> String
$cshowList :: [CSSize] -> ShowS
showList :: [CSSize] -> ShowS
Show, CSSize -> CSSize -> Bool
(CSSize -> CSSize -> Bool)
-> (CSSize -> CSSize -> Bool) -> Eq CSSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CSSize -> CSSize -> Bool
== :: CSSize -> CSSize -> Bool
$c/= :: CSSize -> CSSize -> Bool
/= :: CSSize -> CSSize -> Bool
Eq, Eq CSSize
Eq CSSize =>
(CSSize -> CSSize -> Ordering)
-> (CSSize -> CSSize -> Bool)
-> (CSSize -> CSSize -> Bool)
-> (CSSize -> CSSize -> Bool)
-> (CSSize -> CSSize -> Bool)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> Ord CSSize
CSSize -> CSSize -> Bool
CSSize -> CSSize -> Ordering
CSSize -> CSSize -> CSSize
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CSSize -> CSSize -> Ordering
compare :: CSSize -> CSSize -> Ordering
$c< :: CSSize -> CSSize -> Bool
< :: CSSize -> CSSize -> Bool
$c<= :: CSSize -> CSSize -> Bool
<= :: CSSize -> CSSize -> Bool
$c> :: CSSize -> CSSize -> Bool
> :: CSSize -> CSSize -> Bool
$c>= :: CSSize -> CSSize -> Bool
>= :: CSSize -> CSSize -> Bool
$cmax :: CSSize -> CSSize -> CSSize
max :: CSSize -> CSSize -> CSSize
$cmin :: CSSize -> CSSize -> CSSize
min :: CSSize -> CSSize -> CSSize
Ord, Integer -> CSSize
CSSize -> CSSize
CSSize -> CSSize -> CSSize
(CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize)
-> (CSSize -> CSSize)
-> (CSSize -> CSSize)
-> (Integer -> CSSize)
-> Num CSSize
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: CSSize -> CSSize -> CSSize
+ :: CSSize -> CSSize -> CSSize
$c- :: CSSize -> CSSize -> CSSize
- :: CSSize -> CSSize -> CSSize
$c* :: CSSize -> CSSize -> CSSize
* :: CSSize -> CSSize -> CSSize
$cnegate :: CSSize -> CSSize
negate :: CSSize -> CSSize
$cabs :: CSSize -> CSSize
abs :: CSSize -> CSSize
$csignum :: CSSize -> CSSize
signum :: CSSize -> CSSize
$cfromInteger :: Integer -> CSSize
fromInteger :: Integer -> CSSize
Num, Eq CSSize
CSSize
Eq CSSize =>
(CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> CSSize
-> (Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> Bool)
-> (CSSize -> Maybe Int)
-> (CSSize -> Int)
-> (CSSize -> Bool)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int -> CSSize)
-> (CSSize -> Int)
-> Bits CSSize
Int -> CSSize
CSSize -> Bool
CSSize -> Int
CSSize -> Maybe Int
CSSize -> CSSize
CSSize -> Int -> Bool
CSSize -> Int -> CSSize
CSSize -> CSSize -> CSSize
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: CSSize -> CSSize -> CSSize
.&. :: CSSize -> CSSize -> CSSize
$c.|. :: CSSize -> CSSize -> CSSize
.|. :: CSSize -> CSSize -> CSSize
$cxor :: CSSize -> CSSize -> CSSize
xor :: CSSize -> CSSize -> CSSize
$ccomplement :: CSSize -> CSSize
complement :: CSSize -> CSSize
$cshift :: CSSize -> Int -> CSSize
shift :: CSSize -> Int -> CSSize
$crotate :: CSSize -> Int -> CSSize
rotate :: CSSize -> Int -> CSSize
$czeroBits :: CSSize
zeroBits :: CSSize
$cbit :: Int -> CSSize
bit :: Int -> CSSize
$csetBit :: CSSize -> Int -> CSSize
setBit :: CSSize -> Int -> CSSize
$cclearBit :: CSSize -> Int -> CSSize
clearBit :: CSSize -> Int -> CSSize
$ccomplementBit :: CSSize -> Int -> CSSize
complementBit :: CSSize -> Int -> CSSize
$ctestBit :: CSSize -> Int -> Bool
testBit :: CSSize -> Int -> Bool
$cbitSizeMaybe :: CSSize -> Maybe Int
bitSizeMaybe :: CSSize -> Maybe Int
$cbitSize :: CSSize -> Int
bitSize :: CSSize -> Int
$cisSigned :: CSSize -> Bool
isSigned :: CSSize -> Bool
$cshiftL :: CSSize -> Int -> CSSize
shiftL :: CSSize -> Int -> CSSize
$cunsafeShiftL :: CSSize -> Int -> CSSize
unsafeShiftL :: CSSize -> Int -> CSSize
$cshiftR :: CSSize -> Int -> CSSize
shiftR :: CSSize -> Int -> CSSize
$cunsafeShiftR :: CSSize -> Int -> CSSize
unsafeShiftR :: CSSize -> Int -> CSSize
$crotateL :: CSSize -> Int -> CSSize
rotateL :: CSSize -> Int -> CSSize
$crotateR :: CSSize -> Int -> CSSize
rotateR :: CSSize -> Int -> CSSize
$cpopCount :: CSSize -> Int
popCount :: CSSize -> Int
Bits, Int -> CSSize
CSSize -> Int
CSSize -> [CSSize]
CSSize -> CSSize
CSSize -> CSSize -> [CSSize]
CSSize -> CSSize -> CSSize -> [CSSize]
(CSSize -> CSSize)
-> (CSSize -> CSSize)
-> (Int -> CSSize)
-> (CSSize -> Int)
-> (CSSize -> [CSSize])
-> (CSSize -> CSSize -> [CSSize])
-> (CSSize -> CSSize -> [CSSize])
-> (CSSize -> CSSize -> CSSize -> [CSSize])
-> Enum CSSize
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CSSize -> CSSize
succ :: CSSize -> CSSize
$cpred :: CSSize -> CSSize
pred :: CSSize -> CSSize
$ctoEnum :: Int -> CSSize
toEnum :: Int -> CSSize
$cfromEnum :: CSSize -> Int
fromEnum :: CSSize -> Int
$cenumFrom :: CSSize -> [CSSize]
enumFrom :: CSSize -> [CSSize]
$cenumFromThen :: CSSize -> CSSize -> [CSSize]
enumFromThen :: CSSize -> CSSize -> [CSSize]
$cenumFromTo :: CSSize -> CSSize -> [CSSize]
enumFromTo :: CSSize -> CSSize -> [CSSize]
$cenumFromThenTo :: CSSize -> CSSize -> CSSize -> [CSSize]
enumFromThenTo :: CSSize -> CSSize -> CSSize -> [CSSize]
Enum, CSSize
CSSize -> CSSize -> Bounded CSSize
forall a. a -> a -> Bounded a
$cminBound :: CSSize
minBound :: CSSize
$cmaxBound :: CSSize
maxBound :: CSSize
Bounded, Num CSSize
Ord CSSize
(Num CSSize, Ord CSSize) => (CSSize -> Rational) -> Real CSSize
CSSize -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: CSSize -> Rational
toRational :: CSSize -> Rational
Real, Enum CSSize
Real CSSize
(Real CSSize, Enum CSSize) =>
(CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> CSSize)
-> (CSSize -> CSSize -> (CSSize, CSSize))
-> (CSSize -> CSSize -> (CSSize, CSSize))
-> (CSSize -> Integer)
-> Integral CSSize
CSSize -> Integer
CSSize -> CSSize -> (CSSize, CSSize)
CSSize -> CSSize -> CSSize
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: CSSize -> CSSize -> CSSize
quot :: CSSize -> CSSize -> CSSize
$crem :: CSSize -> CSSize -> CSSize
rem :: CSSize -> CSSize -> CSSize
$cdiv :: CSSize -> CSSize -> CSSize
div :: CSSize -> CSSize -> CSSize
$cmod :: CSSize -> CSSize -> CSSize
mod :: CSSize -> CSSize -> CSSize
$cquotRem :: CSSize -> CSSize -> (CSSize, CSSize)
quotRem :: CSSize -> CSSize -> (CSSize, CSSize)
$cdivMod :: CSSize -> CSSize -> (CSSize, CSSize)
divMod :: CSSize -> CSSize -> (CSSize, CSSize)
$ctoInteger :: CSSize -> Integer
toInteger :: CSSize -> Integer
Integral)

{-# LINE 91 "src/Bindings/HDF5/Raw/H5.hsc" #-}

h5_SIZEOF_SSIZE_T :: CSize
h5_SIZEOF_SSIZE_T :: CSize
h5_SIZEOF_SSIZE_T = CSize
8
{-# LINE 94 "src/Bindings/HDF5/Raw/H5.hsc" #-}

newtype HSize_t = HSize_t Word64 deriving (Ptr HSize_t -> IO HSize_t
Ptr HSize_t -> Int -> IO HSize_t
Ptr HSize_t -> Int -> HSize_t -> IO ()
Ptr HSize_t -> HSize_t -> IO ()
HSize_t -> Int
(HSize_t -> Int)
-> (HSize_t -> Int)
-> (Ptr HSize_t -> Int -> IO HSize_t)
-> (Ptr HSize_t -> Int -> HSize_t -> IO ())
-> (forall b. Ptr b -> Int -> IO HSize_t)
-> (forall b. Ptr b -> Int -> HSize_t -> IO ())
-> (Ptr HSize_t -> IO HSize_t)
-> (Ptr HSize_t -> HSize_t -> IO ())
-> Storable HSize_t
forall b. Ptr b -> Int -> IO HSize_t
forall b. Ptr b -> Int -> HSize_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: HSize_t -> Int
sizeOf :: HSize_t -> Int
$calignment :: HSize_t -> Int
alignment :: HSize_t -> Int
$cpeekElemOff :: Ptr HSize_t -> Int -> IO HSize_t
peekElemOff :: Ptr HSize_t -> Int -> IO HSize_t
$cpokeElemOff :: Ptr HSize_t -> Int -> HSize_t -> IO ()
pokeElemOff :: Ptr HSize_t -> Int -> HSize_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO HSize_t
peekByteOff :: forall b. Ptr b -> Int -> IO HSize_t
$cpokeByteOff :: forall b. Ptr b -> Int -> HSize_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> HSize_t -> IO ()
$cpeek :: Ptr HSize_t -> IO HSize_t
peek :: Ptr HSize_t -> IO HSize_t
$cpoke :: Ptr HSize_t -> HSize_t -> IO ()
poke :: Ptr HSize_t -> HSize_t -> IO ()
Storable, Int -> HSize_t -> ShowS
[HSize_t] -> ShowS
HSize_t -> String
(Int -> HSize_t -> ShowS)
-> (HSize_t -> String) -> ([HSize_t] -> ShowS) -> Show HSize_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HSize_t -> ShowS
showsPrec :: Int -> HSize_t -> ShowS
$cshow :: HSize_t -> String
show :: HSize_t -> String
$cshowList :: [HSize_t] -> ShowS
showList :: [HSize_t] -> ShowS
Show, HSize_t -> HSize_t -> Bool
(HSize_t -> HSize_t -> Bool)
-> (HSize_t -> HSize_t -> Bool) -> Eq HSize_t
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HSize_t -> HSize_t -> Bool
== :: HSize_t -> HSize_t -> Bool
$c/= :: HSize_t -> HSize_t -> Bool
/= :: HSize_t -> HSize_t -> Bool
Eq, Eq HSize_t
Eq HSize_t =>
(HSize_t -> HSize_t -> Ordering)
-> (HSize_t -> HSize_t -> Bool)
-> (HSize_t -> HSize_t -> Bool)
-> (HSize_t -> HSize_t -> Bool)
-> (HSize_t -> HSize_t -> Bool)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> Ord HSize_t
HSize_t -> HSize_t -> Bool
HSize_t -> HSize_t -> Ordering
HSize_t -> HSize_t -> HSize_t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HSize_t -> HSize_t -> Ordering
compare :: HSize_t -> HSize_t -> Ordering
$c< :: HSize_t -> HSize_t -> Bool
< :: HSize_t -> HSize_t -> Bool
$c<= :: HSize_t -> HSize_t -> Bool
<= :: HSize_t -> HSize_t -> Bool
$c> :: HSize_t -> HSize_t -> Bool
> :: HSize_t -> HSize_t -> Bool
$c>= :: HSize_t -> HSize_t -> Bool
>= :: HSize_t -> HSize_t -> Bool
$cmax :: HSize_t -> HSize_t -> HSize_t
max :: HSize_t -> HSize_t -> HSize_t
$cmin :: HSize_t -> HSize_t -> HSize_t
min :: HSize_t -> HSize_t -> HSize_t
Ord, Integer -> HSize_t
HSize_t -> HSize_t
HSize_t -> HSize_t -> HSize_t
(HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t)
-> (HSize_t -> HSize_t)
-> (HSize_t -> HSize_t)
-> (Integer -> HSize_t)
-> Num HSize_t
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: HSize_t -> HSize_t -> HSize_t
+ :: HSize_t -> HSize_t -> HSize_t
$c- :: HSize_t -> HSize_t -> HSize_t
- :: HSize_t -> HSize_t -> HSize_t
$c* :: HSize_t -> HSize_t -> HSize_t
* :: HSize_t -> HSize_t -> HSize_t
$cnegate :: HSize_t -> HSize_t
negate :: HSize_t -> HSize_t
$cabs :: HSize_t -> HSize_t
abs :: HSize_t -> HSize_t
$csignum :: HSize_t -> HSize_t
signum :: HSize_t -> HSize_t
$cfromInteger :: Integer -> HSize_t
fromInteger :: Integer -> HSize_t
Num, Eq HSize_t
HSize_t
Eq HSize_t =>
(HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> HSize_t
-> (Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> Bool)
-> (HSize_t -> Maybe Int)
-> (HSize_t -> Int)
-> (HSize_t -> Bool)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int -> HSize_t)
-> (HSize_t -> Int)
-> Bits HSize_t
Int -> HSize_t
HSize_t -> Bool
HSize_t -> Int
HSize_t -> Maybe Int
HSize_t -> HSize_t
HSize_t -> Int -> Bool
HSize_t -> Int -> HSize_t
HSize_t -> HSize_t -> HSize_t
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: HSize_t -> HSize_t -> HSize_t
.&. :: HSize_t -> HSize_t -> HSize_t
$c.|. :: HSize_t -> HSize_t -> HSize_t
.|. :: HSize_t -> HSize_t -> HSize_t
$cxor :: HSize_t -> HSize_t -> HSize_t
xor :: HSize_t -> HSize_t -> HSize_t
$ccomplement :: HSize_t -> HSize_t
complement :: HSize_t -> HSize_t
$cshift :: HSize_t -> Int -> HSize_t
shift :: HSize_t -> Int -> HSize_t
$crotate :: HSize_t -> Int -> HSize_t
rotate :: HSize_t -> Int -> HSize_t
$czeroBits :: HSize_t
zeroBits :: HSize_t
$cbit :: Int -> HSize_t
bit :: Int -> HSize_t
$csetBit :: HSize_t -> Int -> HSize_t
setBit :: HSize_t -> Int -> HSize_t
$cclearBit :: HSize_t -> Int -> HSize_t
clearBit :: HSize_t -> Int -> HSize_t
$ccomplementBit :: HSize_t -> Int -> HSize_t
complementBit :: HSize_t -> Int -> HSize_t
$ctestBit :: HSize_t -> Int -> Bool
testBit :: HSize_t -> Int -> Bool
$cbitSizeMaybe :: HSize_t -> Maybe Int
bitSizeMaybe :: HSize_t -> Maybe Int
$cbitSize :: HSize_t -> Int
bitSize :: HSize_t -> Int
$cisSigned :: HSize_t -> Bool
isSigned :: HSize_t -> Bool
$cshiftL :: HSize_t -> Int -> HSize_t
shiftL :: HSize_t -> Int -> HSize_t
$cunsafeShiftL :: HSize_t -> Int -> HSize_t
unsafeShiftL :: HSize_t -> Int -> HSize_t
$cshiftR :: HSize_t -> Int -> HSize_t
shiftR :: HSize_t -> Int -> HSize_t
$cunsafeShiftR :: HSize_t -> Int -> HSize_t
unsafeShiftR :: HSize_t -> Int -> HSize_t
$crotateL :: HSize_t -> Int -> HSize_t
rotateL :: HSize_t -> Int -> HSize_t
$crotateR :: HSize_t -> Int -> HSize_t
rotateR :: HSize_t -> Int -> HSize_t
$cpopCount :: HSize_t -> Int
popCount :: HSize_t -> Int
Bits, Int -> HSize_t
HSize_t -> Int
HSize_t -> [HSize_t]
HSize_t -> HSize_t
HSize_t -> HSize_t -> [HSize_t]
HSize_t -> HSize_t -> HSize_t -> [HSize_t]
(HSize_t -> HSize_t)
-> (HSize_t -> HSize_t)
-> (Int -> HSize_t)
-> (HSize_t -> Int)
-> (HSize_t -> [HSize_t])
-> (HSize_t -> HSize_t -> [HSize_t])
-> (HSize_t -> HSize_t -> [HSize_t])
-> (HSize_t -> HSize_t -> HSize_t -> [HSize_t])
-> Enum HSize_t
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HSize_t -> HSize_t
succ :: HSize_t -> HSize_t
$cpred :: HSize_t -> HSize_t
pred :: HSize_t -> HSize_t
$ctoEnum :: Int -> HSize_t
toEnum :: Int -> HSize_t
$cfromEnum :: HSize_t -> Int
fromEnum :: HSize_t -> Int
$cenumFrom :: HSize_t -> [HSize_t]
enumFrom :: HSize_t -> [HSize_t]
$cenumFromThen :: HSize_t -> HSize_t -> [HSize_t]
enumFromThen :: HSize_t -> HSize_t -> [HSize_t]
$cenumFromTo :: HSize_t -> HSize_t -> [HSize_t]
enumFromTo :: HSize_t -> HSize_t -> [HSize_t]
$cenumFromThenTo :: HSize_t -> HSize_t -> HSize_t -> [HSize_t]
enumFromThenTo :: HSize_t -> HSize_t -> HSize_t -> [HSize_t]
Enum, HSize_t
HSize_t -> HSize_t -> Bounded HSize_t
forall a. a -> a -> Bounded a
$cminBound :: HSize_t
minBound :: HSize_t
$cmaxBound :: HSize_t
maxBound :: HSize_t
Bounded, Num HSize_t
Ord HSize_t
(Num HSize_t, Ord HSize_t) => (HSize_t -> Rational) -> Real HSize_t
HSize_t -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: HSize_t -> Rational
toRational :: HSize_t -> Rational
Real, Enum HSize_t
Real HSize_t
(Real HSize_t, Enum HSize_t) =>
(HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> HSize_t)
-> (HSize_t -> HSize_t -> (HSize_t, HSize_t))
-> (HSize_t -> HSize_t -> (HSize_t, HSize_t))
-> (HSize_t -> Integer)
-> Integral HSize_t
HSize_t -> Integer
HSize_t -> HSize_t -> (HSize_t, HSize_t)
HSize_t -> HSize_t -> HSize_t
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: HSize_t -> HSize_t -> HSize_t
quot :: HSize_t -> HSize_t -> HSize_t
$crem :: HSize_t -> HSize_t -> HSize_t
rem :: HSize_t -> HSize_t -> HSize_t
$cdiv :: HSize_t -> HSize_t -> HSize_t
div :: HSize_t -> HSize_t -> HSize_t
$cmod :: HSize_t -> HSize_t -> HSize_t
mod :: HSize_t -> HSize_t -> HSize_t
$cquotRem :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
quotRem :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
$cdivMod :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
divMod :: HSize_t -> HSize_t -> (HSize_t, HSize_t)
$ctoInteger :: HSize_t -> Integer
toInteger :: HSize_t -> Integer
Integral)

{-# LINE 96 "src/Bindings/HDF5/Raw/H5.hsc" #-}
newtype HSSize_t = HSSize_t Int64 deriving (Storable, Show, Eq, Ord, Num, Bits, Enum, Bounded, Real, Integral)

{-# LINE 97 "src/Bindings/HDF5/Raw/H5.hsc" #-}

h5_SIZEOF_HSIZE_T, h5_SIZEOF_HSSIZE_T :: CSize
h5_SIZEOF_HSIZE_T :: CSize
h5_SIZEOF_HSIZE_T  = CSize
8
{-# LINE 100 "src/Bindings/HDF5/Raw/H5.hsc" #-}
h5_SIZEOF_HSSIZE_T = 8
{-# LINE 101 "src/Bindings/HDF5/Raw/H5.hsc" #-}

hSIZE_UNDEF :: HSize_t
hSIZE_UNDEF :: HSize_t
hSIZE_UNDEF = HSize_t
18446744073709551615
{-# LINE 104 "src/Bindings/HDF5/Raw/H5.hsc" #-}

newtype HAddr_t = HAddr_t Word64 deriving (Ptr HAddr_t -> IO HAddr_t
Ptr HAddr_t -> Int -> IO HAddr_t
Ptr HAddr_t -> Int -> HAddr_t -> IO ()
Ptr HAddr_t -> HAddr_t -> IO ()
HAddr_t -> Int
(HAddr_t -> Int)
-> (HAddr_t -> Int)
-> (Ptr HAddr_t -> Int -> IO HAddr_t)
-> (Ptr HAddr_t -> Int -> HAddr_t -> IO ())
-> (forall b. Ptr b -> Int -> IO HAddr_t)
-> (forall b. Ptr b -> Int -> HAddr_t -> IO ())
-> (Ptr HAddr_t -> IO HAddr_t)
-> (Ptr HAddr_t -> HAddr_t -> IO ())
-> Storable HAddr_t
forall b. Ptr b -> Int -> IO HAddr_t
forall b. Ptr b -> Int -> HAddr_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: HAddr_t -> Int
sizeOf :: HAddr_t -> Int
$calignment :: HAddr_t -> Int
alignment :: HAddr_t -> Int
$cpeekElemOff :: Ptr HAddr_t -> Int -> IO HAddr_t
peekElemOff :: Ptr HAddr_t -> Int -> IO HAddr_t
$cpokeElemOff :: Ptr HAddr_t -> Int -> HAddr_t -> IO ()
pokeElemOff :: Ptr HAddr_t -> Int -> HAddr_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO HAddr_t
peekByteOff :: forall b. Ptr b -> Int -> IO HAddr_t
$cpokeByteOff :: forall b. Ptr b -> Int -> HAddr_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> HAddr_t -> IO ()
$cpeek :: Ptr HAddr_t -> IO HAddr_t
peek :: Ptr HAddr_t -> IO HAddr_t
$cpoke :: Ptr HAddr_t -> HAddr_t -> IO ()
poke :: Ptr HAddr_t -> HAddr_t -> IO ()
Storable, Int -> HAddr_t -> ShowS
[HAddr_t] -> ShowS
HAddr_t -> String
(Int -> HAddr_t -> ShowS)
-> (HAddr_t -> String) -> ([HAddr_t] -> ShowS) -> Show HAddr_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HAddr_t -> ShowS
showsPrec :: Int -> HAddr_t -> ShowS
$cshow :: HAddr_t -> String
show :: HAddr_t -> String
$cshowList :: [HAddr_t] -> ShowS
showList :: [HAddr_t] -> ShowS
Show, HAddr_t -> HAddr_t -> Bool
(HAddr_t -> HAddr_t -> Bool)
-> (HAddr_t -> HAddr_t -> Bool) -> Eq HAddr_t
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HAddr_t -> HAddr_t -> Bool
== :: HAddr_t -> HAddr_t -> Bool
$c/= :: HAddr_t -> HAddr_t -> Bool
/= :: HAddr_t -> HAddr_t -> Bool
Eq, Eq HAddr_t
Eq HAddr_t =>
(HAddr_t -> HAddr_t -> Ordering)
-> (HAddr_t -> HAddr_t -> Bool)
-> (HAddr_t -> HAddr_t -> Bool)
-> (HAddr_t -> HAddr_t -> Bool)
-> (HAddr_t -> HAddr_t -> Bool)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> Ord HAddr_t
HAddr_t -> HAddr_t -> Bool
HAddr_t -> HAddr_t -> Ordering
HAddr_t -> HAddr_t -> HAddr_t
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: HAddr_t -> HAddr_t -> Ordering
compare :: HAddr_t -> HAddr_t -> Ordering
$c< :: HAddr_t -> HAddr_t -> Bool
< :: HAddr_t -> HAddr_t -> Bool
$c<= :: HAddr_t -> HAddr_t -> Bool
<= :: HAddr_t -> HAddr_t -> Bool
$c> :: HAddr_t -> HAddr_t -> Bool
> :: HAddr_t -> HAddr_t -> Bool
$c>= :: HAddr_t -> HAddr_t -> Bool
>= :: HAddr_t -> HAddr_t -> Bool
$cmax :: HAddr_t -> HAddr_t -> HAddr_t
max :: HAddr_t -> HAddr_t -> HAddr_t
$cmin :: HAddr_t -> HAddr_t -> HAddr_t
min :: HAddr_t -> HAddr_t -> HAddr_t
Ord, Integer -> HAddr_t
HAddr_t -> HAddr_t
HAddr_t -> HAddr_t -> HAddr_t
(HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t)
-> (Integer -> HAddr_t)
-> Num HAddr_t
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: HAddr_t -> HAddr_t -> HAddr_t
+ :: HAddr_t -> HAddr_t -> HAddr_t
$c- :: HAddr_t -> HAddr_t -> HAddr_t
- :: HAddr_t -> HAddr_t -> HAddr_t
$c* :: HAddr_t -> HAddr_t -> HAddr_t
* :: HAddr_t -> HAddr_t -> HAddr_t
$cnegate :: HAddr_t -> HAddr_t
negate :: HAddr_t -> HAddr_t
$cabs :: HAddr_t -> HAddr_t
abs :: HAddr_t -> HAddr_t
$csignum :: HAddr_t -> HAddr_t
signum :: HAddr_t -> HAddr_t
$cfromInteger :: Integer -> HAddr_t
fromInteger :: Integer -> HAddr_t
Num, Eq HAddr_t
HAddr_t
Eq HAddr_t =>
(HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> HAddr_t
-> (Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> Bool)
-> (HAddr_t -> Maybe Int)
-> (HAddr_t -> Int)
-> (HAddr_t -> Bool)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int -> HAddr_t)
-> (HAddr_t -> Int)
-> Bits HAddr_t
Int -> HAddr_t
HAddr_t -> Bool
HAddr_t -> Int
HAddr_t -> Maybe Int
HAddr_t -> HAddr_t
HAddr_t -> Int -> Bool
HAddr_t -> Int -> HAddr_t
HAddr_t -> HAddr_t -> HAddr_t
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: HAddr_t -> HAddr_t -> HAddr_t
.&. :: HAddr_t -> HAddr_t -> HAddr_t
$c.|. :: HAddr_t -> HAddr_t -> HAddr_t
.|. :: HAddr_t -> HAddr_t -> HAddr_t
$cxor :: HAddr_t -> HAddr_t -> HAddr_t
xor :: HAddr_t -> HAddr_t -> HAddr_t
$ccomplement :: HAddr_t -> HAddr_t
complement :: HAddr_t -> HAddr_t
$cshift :: HAddr_t -> Int -> HAddr_t
shift :: HAddr_t -> Int -> HAddr_t
$crotate :: HAddr_t -> Int -> HAddr_t
rotate :: HAddr_t -> Int -> HAddr_t
$czeroBits :: HAddr_t
zeroBits :: HAddr_t
$cbit :: Int -> HAddr_t
bit :: Int -> HAddr_t
$csetBit :: HAddr_t -> Int -> HAddr_t
setBit :: HAddr_t -> Int -> HAddr_t
$cclearBit :: HAddr_t -> Int -> HAddr_t
clearBit :: HAddr_t -> Int -> HAddr_t
$ccomplementBit :: HAddr_t -> Int -> HAddr_t
complementBit :: HAddr_t -> Int -> HAddr_t
$ctestBit :: HAddr_t -> Int -> Bool
testBit :: HAddr_t -> Int -> Bool
$cbitSizeMaybe :: HAddr_t -> Maybe Int
bitSizeMaybe :: HAddr_t -> Maybe Int
$cbitSize :: HAddr_t -> Int
bitSize :: HAddr_t -> Int
$cisSigned :: HAddr_t -> Bool
isSigned :: HAddr_t -> Bool
$cshiftL :: HAddr_t -> Int -> HAddr_t
shiftL :: HAddr_t -> Int -> HAddr_t
$cunsafeShiftL :: HAddr_t -> Int -> HAddr_t
unsafeShiftL :: HAddr_t -> Int -> HAddr_t
$cshiftR :: HAddr_t -> Int -> HAddr_t
shiftR :: HAddr_t -> Int -> HAddr_t
$cunsafeShiftR :: HAddr_t -> Int -> HAddr_t
unsafeShiftR :: HAddr_t -> Int -> HAddr_t
$crotateL :: HAddr_t -> Int -> HAddr_t
rotateL :: HAddr_t -> Int -> HAddr_t
$crotateR :: HAddr_t -> Int -> HAddr_t
rotateR :: HAddr_t -> Int -> HAddr_t
$cpopCount :: HAddr_t -> Int
popCount :: HAddr_t -> Int
Bits, Int -> HAddr_t
HAddr_t -> Int
HAddr_t -> [HAddr_t]
HAddr_t -> HAddr_t
HAddr_t -> HAddr_t -> [HAddr_t]
HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
(HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t)
-> (Int -> HAddr_t)
-> (HAddr_t -> Int)
-> (HAddr_t -> [HAddr_t])
-> (HAddr_t -> HAddr_t -> [HAddr_t])
-> (HAddr_t -> HAddr_t -> [HAddr_t])
-> (HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t])
-> Enum HAddr_t
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HAddr_t -> HAddr_t
succ :: HAddr_t -> HAddr_t
$cpred :: HAddr_t -> HAddr_t
pred :: HAddr_t -> HAddr_t
$ctoEnum :: Int -> HAddr_t
toEnum :: Int -> HAddr_t
$cfromEnum :: HAddr_t -> Int
fromEnum :: HAddr_t -> Int
$cenumFrom :: HAddr_t -> [HAddr_t]
enumFrom :: HAddr_t -> [HAddr_t]
$cenumFromThen :: HAddr_t -> HAddr_t -> [HAddr_t]
enumFromThen :: HAddr_t -> HAddr_t -> [HAddr_t]
$cenumFromTo :: HAddr_t -> HAddr_t -> [HAddr_t]
enumFromTo :: HAddr_t -> HAddr_t -> [HAddr_t]
$cenumFromThenTo :: HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
enumFromThenTo :: HAddr_t -> HAddr_t -> HAddr_t -> [HAddr_t]
Enum, HAddr_t
HAddr_t -> HAddr_t -> Bounded HAddr_t
forall a. a -> a -> Bounded a
$cminBound :: HAddr_t
minBound :: HAddr_t
$cmaxBound :: HAddr_t
maxBound :: HAddr_t
Bounded, Num HAddr_t
Ord HAddr_t
(Num HAddr_t, Ord HAddr_t) => (HAddr_t -> Rational) -> Real HAddr_t
HAddr_t -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: HAddr_t -> Rational
toRational :: HAddr_t -> Rational
Real, Enum HAddr_t
Real HAddr_t
(Real HAddr_t, Enum HAddr_t) =>
(HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> HAddr_t)
-> (HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t))
-> (HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t))
-> (HAddr_t -> Integer)
-> Integral HAddr_t
HAddr_t -> Integer
HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
HAddr_t -> HAddr_t -> HAddr_t
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: HAddr_t -> HAddr_t -> HAddr_t
quot :: HAddr_t -> HAddr_t -> HAddr_t
$crem :: HAddr_t -> HAddr_t -> HAddr_t
rem :: HAddr_t -> HAddr_t -> HAddr_t
$cdiv :: HAddr_t -> HAddr_t -> HAddr_t
div :: HAddr_t -> HAddr_t -> HAddr_t
$cmod :: HAddr_t -> HAddr_t -> HAddr_t
mod :: HAddr_t -> HAddr_t -> HAddr_t
$cquotRem :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
quotRem :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
$cdivMod :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
divMod :: HAddr_t -> HAddr_t -> (HAddr_t, HAddr_t)
$ctoInteger :: HAddr_t -> Integer
toInteger :: HAddr_t -> Integer
Integral)

{-# LINE 106 "src/Bindings/HDF5/Raw/H5.hsc" #-}

hADDR_UNDEF :: HAddr_t
hADDR_UNDEF :: HAddr_t
hADDR_UNDEF = Word64 -> HAddr_t
HAddr_t (Word64
18446744073709551615)
{-# LINE 109 "src/Bindings/HDF5/Raw/H5.hsc" #-}

h5_SIZEOF_HADDR_T :: CSize
h5_SIZEOF_HADDR_T :: CSize
h5_SIZEOF_HADDR_T = CSize
8
{-# LINE 112 "src/Bindings/HDF5/Raw/H5.hsc" #-}

h5_PRINTF_HADDR_FMT :: String
h5_PRINTF_HADDR_FMT :: String
h5_PRINTF_HADDR_FMT = String
"%lu"

{-# LINE 114 "src/Bindings/HDF5/Raw/H5.hsc" #-}

hADDR_MAX :: HAddr_t
hADDR_MAX = HAddr_t (18446744073709551614)
{-# LINE 117 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Common iteration orders
newtype H5_iter_order_t = H5_iter_order_t Int32 deriving (Ptr H5_iter_order_t -> IO H5_iter_order_t
Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
H5_iter_order_t -> Int
(H5_iter_order_t -> Int)
-> (H5_iter_order_t -> Int)
-> (Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t)
-> (Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ())
-> (forall b. Ptr b -> Int -> IO H5_iter_order_t)
-> (forall b. Ptr b -> Int -> H5_iter_order_t -> IO ())
-> (Ptr H5_iter_order_t -> IO H5_iter_order_t)
-> (Ptr H5_iter_order_t -> H5_iter_order_t -> IO ())
-> Storable H5_iter_order_t
forall b. Ptr b -> Int -> IO H5_iter_order_t
forall b. Ptr b -> Int -> H5_iter_order_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: H5_iter_order_t -> Int
sizeOf :: H5_iter_order_t -> Int
$calignment :: H5_iter_order_t -> Int
alignment :: H5_iter_order_t -> Int
$cpeekElemOff :: Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
peekElemOff :: Ptr H5_iter_order_t -> Int -> IO H5_iter_order_t
$cpokeElemOff :: Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
pokeElemOff :: Ptr H5_iter_order_t -> Int -> H5_iter_order_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO H5_iter_order_t
peekByteOff :: forall b. Ptr b -> Int -> IO H5_iter_order_t
$cpokeByteOff :: forall b. Ptr b -> Int -> H5_iter_order_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> H5_iter_order_t -> IO ()
$cpeek :: Ptr H5_iter_order_t -> IO H5_iter_order_t
peek :: Ptr H5_iter_order_t -> IO H5_iter_order_t
$cpoke :: Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
poke :: Ptr H5_iter_order_t -> H5_iter_order_t -> IO ()
Storable, Int -> H5_iter_order_t -> ShowS
[H5_iter_order_t] -> ShowS
H5_iter_order_t -> String
(Int -> H5_iter_order_t -> ShowS)
-> (H5_iter_order_t -> String)
-> ([H5_iter_order_t] -> ShowS)
-> Show H5_iter_order_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> H5_iter_order_t -> ShowS
showsPrec :: Int -> H5_iter_order_t -> ShowS
$cshow :: H5_iter_order_t -> String
show :: H5_iter_order_t -> String
$cshowList :: [H5_iter_order_t] -> ShowS
showList :: [H5_iter_order_t] -> ShowS
Show)

{-# LINE 120 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Unknown order
h5_ITER_UNKNOWN :: H5_iter_order_t
h5_ITER_UNKNOWN :: H5_iter_order_t
h5_ITER_UNKNOWN = Int32 -> H5_iter_order_t
H5_iter_order_t (-Int32
1)

{-# LINE 123 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Increasing order
h5_ITER_INC :: H5_iter_order_t
h5_ITER_INC :: H5_iter_order_t
h5_ITER_INC = Int32 -> H5_iter_order_t
H5_iter_order_t (Int32
0)

{-# LINE 126 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Decreasing order
h5_ITER_DEC :: H5_iter_order_t
h5_ITER_DEC :: H5_iter_order_t
h5_ITER_DEC = Int32 -> H5_iter_order_t
H5_iter_order_t (Int32
1)

{-# LINE 129 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |No particular order, whatever is fastest
h5_ITER_NATIVE :: H5_iter_order_t
h5_ITER_NATIVE :: H5_iter_order_t
h5_ITER_NATIVE = Int32 -> H5_iter_order_t
H5_iter_order_t (Int32
2)

{-# LINE 132 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Number of iteration orders
h5_ITER_N = 3
h5_ITER_N :: (Num a) => a

{-# LINE 135 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Iteration callback return value indicating that iteration should stop
-- and report an error.
h5_ITER_ERROR :: HErr_t
h5_ITER_ERROR :: HErr_t
h5_ITER_ERROR = Int32 -> HErr_t
HErr_t (-Int32
1)

{-# LINE 139 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Iteration callback return value indicating that iteration should continue.
h5_ITER_CONT :: HErr_t
h5_ITER_CONT :: HErr_t
h5_ITER_CONT = Int32 -> HErr_t
HErr_t (Int32
0)

{-# LINE 142 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Iteration callback return value indicating that iteration should stop
-- without error.
--
-- Actually, any postive value will cause the iterator to stop and pass back
-- that positive value to the function that called the iterator
h5_ITER_STOP :: HErr_t
h5_ITER_STOP :: HErr_t
h5_ITER_STOP = Int32 -> HErr_t
HErr_t (Int32
1)

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

-- |The types of indices on links in groups/attributes on objects.
-- Primarily used for \"\<do\> \<foo\> by index\" routines and for iterating over
-- links in groups/attributes on objects.
newtype H5_index_t = H5_index_t Int32 deriving (Ptr H5_index_t -> IO H5_index_t
Ptr H5_index_t -> Int -> IO H5_index_t
Ptr H5_index_t -> Int -> H5_index_t -> IO ()
Ptr H5_index_t -> H5_index_t -> IO ()
H5_index_t -> Int
(H5_index_t -> Int)
-> (H5_index_t -> Int)
-> (Ptr H5_index_t -> Int -> IO H5_index_t)
-> (Ptr H5_index_t -> Int -> H5_index_t -> IO ())
-> (forall b. Ptr b -> Int -> IO H5_index_t)
-> (forall b. Ptr b -> Int -> H5_index_t -> IO ())
-> (Ptr H5_index_t -> IO H5_index_t)
-> (Ptr H5_index_t -> H5_index_t -> IO ())
-> Storable H5_index_t
forall b. Ptr b -> Int -> IO H5_index_t
forall b. Ptr b -> Int -> H5_index_t -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
$csizeOf :: H5_index_t -> Int
sizeOf :: H5_index_t -> Int
$calignment :: H5_index_t -> Int
alignment :: H5_index_t -> Int
$cpeekElemOff :: Ptr H5_index_t -> Int -> IO H5_index_t
peekElemOff :: Ptr H5_index_t -> Int -> IO H5_index_t
$cpokeElemOff :: Ptr H5_index_t -> Int -> H5_index_t -> IO ()
pokeElemOff :: Ptr H5_index_t -> Int -> H5_index_t -> IO ()
$cpeekByteOff :: forall b. Ptr b -> Int -> IO H5_index_t
peekByteOff :: forall b. Ptr b -> Int -> IO H5_index_t
$cpokeByteOff :: forall b. Ptr b -> Int -> H5_index_t -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> H5_index_t -> IO ()
$cpeek :: Ptr H5_index_t -> IO H5_index_t
peek :: Ptr H5_index_t -> IO H5_index_t
$cpoke :: Ptr H5_index_t -> H5_index_t -> IO ()
poke :: Ptr H5_index_t -> H5_index_t -> IO ()
Storable, Int -> H5_index_t -> ShowS
[H5_index_t] -> ShowS
H5_index_t -> String
(Int -> H5_index_t -> ShowS)
-> (H5_index_t -> String)
-> ([H5_index_t] -> ShowS)
-> Show H5_index_t
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> H5_index_t -> ShowS
showsPrec :: Int -> H5_index_t -> ShowS
$cshow :: H5_index_t -> String
show :: H5_index_t -> String
$cshowList :: [H5_index_t] -> ShowS
showList :: [H5_index_t] -> ShowS
Show)

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

-- |Unknown index type
h5_INDEX_UNKNOWN :: H5_index_t
h5_INDEX_UNKNOWN :: H5_index_t
h5_INDEX_UNKNOWN = Int32 -> H5_index_t
H5_index_t (-Int32
1)

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

-- |Index on names
h5_INDEX_NAME :: H5_index_t
h5_INDEX_NAME :: H5_index_t
h5_INDEX_NAME = Int32 -> H5_index_t
H5_index_t (Int32
0)

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

-- |Index on creation order
h5_INDEX_CRT_ORDER :: H5_index_t
h5_INDEX_CRT_ORDER :: H5_index_t
h5_INDEX_CRT_ORDER = Int32 -> H5_index_t
H5_index_t (Int32
1)

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

-- |Number of indices defined
h5_INDEX_N = 2
h5_INDEX_N :: (Num a) => a

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

-- |Storage info struct used by 'H5O_info_t' and 'H5F_info_t'

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

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

{-# LINE 171 "src/Bindings/HDF5/Raw/H5.hsc" #-}
data H5_ih_info_t = H5_ih_info_t{
  h5_ih_info_t'index_size :: HSize_t,
  h5_ih_info_t'heap_size :: HSize_t
} deriving (Eq,Show)
p'H5_ih_info_t'index_size :: Ptr H5_ih_info_t -> Ptr HSize_t
p'H5_ih_info_t'index_size Ptr H5_ih_info_t
p = Ptr H5_ih_info_t -> Int -> Ptr HSize_t
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5_ih_info_t
p Int
0
p'H5_ih_info_t'index_size :: Ptr (H5_ih_info_t) -> Ptr (HSize_t)
p'H5_ih_info_t'heap_size :: Ptr H5_ih_info_t -> Ptr HSize_t
p'H5_ih_info_t'heap_size Ptr H5_ih_info_t
p = Ptr H5_ih_info_t -> Int -> Ptr HSize_t
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr H5_ih_info_t
p Int
8
p'H5_ih_info_t'heap_size :: Ptr (H5_ih_info_t) -> Ptr (HSize_t)
instance Storable H5_ih_info_t where
  sizeOf :: H5_ih_info_t -> Int
sizeOf H5_ih_info_t
_ = Int
16
  alignment :: H5_ih_info_t -> Int
alignment H5_ih_info_t
_ = Int
8
  peek _p = do
    v0 <- peekByteOff _p 0
    v1 <- peekByteOff _p 8
    return $ H5_ih_info_t v0 v1
  poke _p (H5_ih_info_t v0 v1) = do
    pokeByteOff _p 0 v0
    pokeByteOff _p 8 v1
    return ()

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

-- *Functions in H5.c

-- |Initialize the library.  This is normally called automatically, but if you
-- find that an HDF5 library function is failing inexplicably, then try
-- calling this function first.
--
-- Return: Non-negative on success/Negative on failure
--
-- > herr_t H5open(void);
foreign import ccall "H5open" h5_open
  :: IO HErr_t
foreign import ccall "&H5open" p_H5open
  :: FunPtr (IO HErr_t)

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

-- |Terminate the library and release all resources.
--
-- Return: Non-negative on success/Negative on failure
--
-- > herr_t H5close(void);
foreign import ccall "H5close" h5_close
  :: IO HErr_t
foreign import ccall "&H5close" p_H5close
  :: FunPtr (IO HErr_t)

{-# LINE 190 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Indicates that the library is not to clean up after itself
-- when the application exits by calling exit() or returning
-- from main().  This function must be called before any other
-- HDF5 function or constant is used or it will have no effect.
--
-- If this function is used then certain memory buffers will not
-- be de-allocated nor will open files be flushed automatically.
-- The application may still call H5close() explicitly to
-- accomplish these things.
--
-- Return:  non-negative on success,
--          negative if this function is called more than
--          once or if it is called too late.
--
-- > herr_t H5dont_atexit(void);
foreign import ccall "H5dont_atexit" h5_dont_atexit
  :: IO HErr_t
foreign import ccall "&H5dont_atexit" p_H5dont_atexit
  :: FunPtr (IO HErr_t)

{-# LINE 207 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Walks through all the garbage collection routines for the
-- library, which are supposed to free any unused memory they have
-- allocated.
--
-- These should probably be registered dynamicly in a linked list of
-- functions to call, but there aren't that many right now, so we
-- hard-wire them...
--
-- Return: non-negative on success, negative on failure
--
-- > herr_t H5garbage_collect(void);
foreign import ccall "H5garbage_collect" h5_garbage_collect
  :: IO HErr_t
foreign import ccall "&H5garbage_collect" p_H5garbage_collect
  :: FunPtr (IO HErr_t)

{-# LINE 220 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Sets limits on the different kinds of free lists.  Setting a value
-- of -1 for a limit means no limit of that type.  These limits are global
-- for the entire library.  Each \"global\" limit only applies to free lists
-- of that type, so if an application sets a limit of 1 MB on each of the
-- global lists, up to 3 MB of total storage might be allocated (1MB on
-- each of regular, array and block type lists).
--
-- The settings for block free lists are duplicated to factory free lists.
-- Factory free list limits cannot be set independently currently.
--
-- Parameters:
--
-- [@ reg_global_lim :: CInt @]  The limit on all \"regular\" free list memory used
--
-- [@ reg_list_lim   :: CInt @]  The limit on memory used in each \"regular\" free list
--
-- [@ arr_global_lim :: CInt @]  The limit on all \"array\" free list memory used
--
-- [@ arr_list_lim   :: CInt @]  The limit on memory used in each \"array\" free list
--
-- [@ blk_global_lim :: CInt @]  The limit on all \"block\" free list memory used
--
-- [@ blk_list_lim   :: CInt @]  The limit on memory used in each \"block\" free list
--
-- Return: non-negative on success, negative on failure
--
-- > herr_t H5set_free_list_limits (int reg_global_lim, int reg_list_lim,
-- >         int arr_global_lim, int arr_list_lim, int blk_global_lim,
-- >         int blk_list_lim);
foreign import ccall "H5set_free_list_limits" h5_set_free_list_limits
  :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO HErr_t
foreign import ccall "&H5set_free_list_limits" p_H5set_free_list_limits
  :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO HErr_t)

{-# LINE 251 "src/Bindings/HDF5/Raw/H5.hsc" #-}

-- |Returns the library version numbers through arguments. MAJNUM
-- will be the major revision number of the library, MINNUM the
-- minor revision number, and RELNUM the release revision number.
--
-- Note: When printing an HDF5 version number it should be printed as
--
-- > printf("%u.%u.%u", maj, min, rel)		or
-- > printf("version %u.%u release %u", maj, min, rel)
--
-- Return:	Non-negative on success/Negative on failure
--
-- > herr_t H5get_libversion(unsigned *majnum, unsigned *minnum,
-- >         unsigned *relnum);
foreign import ccall "H5get_libversion" h5_get_libversion
  :: Out CUInt -> Out CUInt -> Out CUInt -> IO HErr_t
foreign import ccall "&H5get_libversion" p_H5get_libversion
  :: FunPtr (Out CUInt -> Out CUInt -> Out CUInt -> IO HErr_t)

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

-- |Purpose:	Verifies that the arguments match the version numbers
-- compiled into the library.  This function is intended to be
-- called from user to verify that the versions of header files
-- compiled into the application match the version of the hdf5
-- library.
--
-- Return: Success: 0, Failure: calls abort()
--
-- > herr_t H5check_version(unsigned majnum, unsigned minnum,
-- >         unsigned relnum);
foreign import ccall "H5check_version" h5_check_version
  :: CUInt -> CUInt -> CUInt -> IO HErr_t
foreign import ccall "&H5check_version" p_H5check_version
  :: FunPtr (CUInt -> CUInt -> CUInt -> IO HErr_t)

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