{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Bindings.HDF5.Core
    ( module Bindings.HDF5.Core
    , module Bindings.HDF5.Core.HId
    , module Bindings.HDF5.Core.HDFResultType
    ) where

import Bindings.HDF5.Raw.H5

import Bindings.HDF5.Core.HId
import Bindings.HDF5.Core.HDFResultType

import Data.Bits
import Foreign.Storable

{-# ANN module "HLint: ignore Use camelCase" #-}

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

hSize :: HSize -> HSize_t
hSize :: HSize -> HSize_t
hSize (HSize HSize_t
s) = HSize_t
s

instance Read HSize where
    readsPrec :: Int -> ReadS HSize
readsPrec Int
p String
s =
        [ (HSize_t -> HSize
HSize (Word64 -> HSize_t
HSize_t Word64
n), String
rest)
        | (Word64
n,String
rest) <- Int -> ReadS Word64
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
s
        ]

instance Show HSize where
    showsPrec :: Int -> HSize -> ShowS
showsPrec Int
p (HSize (HSize_t Word64
n)) = Int -> Word64 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p Word64
n

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

hSSize :: HSSize -> HSSize_t
hSSize :: HSSize -> HSSize_t
hSSize (HSSize HSSize_t
s) = HSSize_t
s

instance Read HSSize where
    readsPrec :: Int -> ReadS HSSize
readsPrec Int
p String
s =
        [ (HSSize_t -> HSSize
HSSize (Int64 -> HSSize_t
HSSize_t Int64
n), String
rest)
        | (Int64
n,String
rest) <- Int -> ReadS Int64
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
s
        ]

instance Show HSSize where
    showsPrec :: Int -> HSSize -> ShowS
showsPrec Int
p (HSSize (HSSize_t Int64
n)) = Int -> Int64 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p Int64
n

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

hAddr :: HAddr -> HAddr_t
hAddr :: HAddr -> HAddr_t
hAddr (HAddr HAddr_t
a) = HAddr_t
a

instance Read HAddr where
    readsPrec :: Int -> ReadS HAddr
readsPrec Int
p String
s =
        [ (HAddr_t -> HAddr
HAddr (Word64 -> HAddr_t
HAddr_t Word64
n), String
rest)
        | (Word64
n, String
rest) <- Int -> ReadS Word64
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
s
        ]

instance Show HAddr where
    showsPrec :: Int -> HAddr -> ShowS
showsPrec Int
p (HAddr (HAddr_t Word64
n)) = Int -> Word64 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p Word64
n

data IH_Info = IH_Info
    { IH_Info -> HSize
indexSize     :: !HSize
    , IH_Info -> HSize
heapSize      :: !HSize
    } deriving (IH_Info -> IH_Info -> Bool
(IH_Info -> IH_Info -> Bool)
-> (IH_Info -> IH_Info -> Bool) -> Eq IH_Info
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IH_Info -> IH_Info -> Bool
== :: IH_Info -> IH_Info -> Bool
$c/= :: IH_Info -> IH_Info -> Bool
/= :: IH_Info -> IH_Info -> Bool
Eq, Eq IH_Info
Eq IH_Info =>
(IH_Info -> IH_Info -> Ordering)
-> (IH_Info -> IH_Info -> Bool)
-> (IH_Info -> IH_Info -> Bool)
-> (IH_Info -> IH_Info -> Bool)
-> (IH_Info -> IH_Info -> Bool)
-> (IH_Info -> IH_Info -> IH_Info)
-> (IH_Info -> IH_Info -> IH_Info)
-> Ord IH_Info
IH_Info -> IH_Info -> Bool
IH_Info -> IH_Info -> Ordering
IH_Info -> IH_Info -> IH_Info
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 :: IH_Info -> IH_Info -> Ordering
compare :: IH_Info -> IH_Info -> Ordering
$c< :: IH_Info -> IH_Info -> Bool
< :: IH_Info -> IH_Info -> Bool
$c<= :: IH_Info -> IH_Info -> Bool
<= :: IH_Info -> IH_Info -> Bool
$c> :: IH_Info -> IH_Info -> Bool
> :: IH_Info -> IH_Info -> Bool
$c>= :: IH_Info -> IH_Info -> Bool
>= :: IH_Info -> IH_Info -> Bool
$cmax :: IH_Info -> IH_Info -> IH_Info
max :: IH_Info -> IH_Info -> IH_Info
$cmin :: IH_Info -> IH_Info -> IH_Info
min :: IH_Info -> IH_Info -> IH_Info
Ord, ReadPrec [IH_Info]
ReadPrec IH_Info
Int -> ReadS IH_Info
ReadS [IH_Info]
(Int -> ReadS IH_Info)
-> ReadS [IH_Info]
-> ReadPrec IH_Info
-> ReadPrec [IH_Info]
-> Read IH_Info
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IH_Info
readsPrec :: Int -> ReadS IH_Info
$creadList :: ReadS [IH_Info]
readList :: ReadS [IH_Info]
$creadPrec :: ReadPrec IH_Info
readPrec :: ReadPrec IH_Info
$creadListPrec :: ReadPrec [IH_Info]
readListPrec :: ReadPrec [IH_Info]
Read, Int -> IH_Info -> ShowS
[IH_Info] -> ShowS
IH_Info -> String
(Int -> IH_Info -> ShowS)
-> (IH_Info -> String) -> ([IH_Info] -> ShowS) -> Show IH_Info
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IH_Info -> ShowS
showsPrec :: Int -> IH_Info -> ShowS
$cshow :: IH_Info -> String
show :: IH_Info -> String
$cshowList :: [IH_Info] -> ShowS
showList :: [IH_Info] -> ShowS
Show)

data IndexType
    = ByName
    | ByCreationOrder
    deriving (IndexType -> IndexType -> Bool
(IndexType -> IndexType -> Bool)
-> (IndexType -> IndexType -> Bool) -> Eq IndexType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexType -> IndexType -> Bool
== :: IndexType -> IndexType -> Bool
$c/= :: IndexType -> IndexType -> Bool
/= :: IndexType -> IndexType -> Bool
Eq, Eq IndexType
Eq IndexType =>
(IndexType -> IndexType -> Ordering)
-> (IndexType -> IndexType -> Bool)
-> (IndexType -> IndexType -> Bool)
-> (IndexType -> IndexType -> Bool)
-> (IndexType -> IndexType -> Bool)
-> (IndexType -> IndexType -> IndexType)
-> (IndexType -> IndexType -> IndexType)
-> Ord IndexType
IndexType -> IndexType -> Bool
IndexType -> IndexType -> Ordering
IndexType -> IndexType -> IndexType
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 :: IndexType -> IndexType -> Ordering
compare :: IndexType -> IndexType -> Ordering
$c< :: IndexType -> IndexType -> Bool
< :: IndexType -> IndexType -> Bool
$c<= :: IndexType -> IndexType -> Bool
<= :: IndexType -> IndexType -> Bool
$c> :: IndexType -> IndexType -> Bool
> :: IndexType -> IndexType -> Bool
$c>= :: IndexType -> IndexType -> Bool
>= :: IndexType -> IndexType -> Bool
$cmax :: IndexType -> IndexType -> IndexType
max :: IndexType -> IndexType -> IndexType
$cmin :: IndexType -> IndexType -> IndexType
min :: IndexType -> IndexType -> IndexType
Ord, Int -> IndexType
IndexType -> Int
IndexType -> [IndexType]
IndexType -> IndexType
IndexType -> IndexType -> [IndexType]
IndexType -> IndexType -> IndexType -> [IndexType]
(IndexType -> IndexType)
-> (IndexType -> IndexType)
-> (Int -> IndexType)
-> (IndexType -> Int)
-> (IndexType -> [IndexType])
-> (IndexType -> IndexType -> [IndexType])
-> (IndexType -> IndexType -> [IndexType])
-> (IndexType -> IndexType -> IndexType -> [IndexType])
-> Enum IndexType
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 :: IndexType -> IndexType
succ :: IndexType -> IndexType
$cpred :: IndexType -> IndexType
pred :: IndexType -> IndexType
$ctoEnum :: Int -> IndexType
toEnum :: Int -> IndexType
$cfromEnum :: IndexType -> Int
fromEnum :: IndexType -> Int
$cenumFrom :: IndexType -> [IndexType]
enumFrom :: IndexType -> [IndexType]
$cenumFromThen :: IndexType -> IndexType -> [IndexType]
enumFromThen :: IndexType -> IndexType -> [IndexType]
$cenumFromTo :: IndexType -> IndexType -> [IndexType]
enumFromTo :: IndexType -> IndexType -> [IndexType]
$cenumFromThenTo :: IndexType -> IndexType -> IndexType -> [IndexType]
enumFromThenTo :: IndexType -> IndexType -> IndexType -> [IndexType]
Enum, IndexType
IndexType -> IndexType -> Bounded IndexType
forall a. a -> a -> Bounded a
$cminBound :: IndexType
minBound :: IndexType
$cmaxBound :: IndexType
maxBound :: IndexType
Bounded, ReadPrec [IndexType]
ReadPrec IndexType
Int -> ReadS IndexType
ReadS [IndexType]
(Int -> ReadS IndexType)
-> ReadS [IndexType]
-> ReadPrec IndexType
-> ReadPrec [IndexType]
-> Read IndexType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndexType
readsPrec :: Int -> ReadS IndexType
$creadList :: ReadS [IndexType]
readList :: ReadS [IndexType]
$creadPrec :: ReadPrec IndexType
readPrec :: ReadPrec IndexType
$creadListPrec :: ReadPrec [IndexType]
readListPrec :: ReadPrec [IndexType]
Read, Int -> IndexType -> ShowS
[IndexType] -> ShowS
IndexType -> String
(Int -> IndexType -> ShowS)
-> (IndexType -> String)
-> ([IndexType] -> ShowS)
-> Show IndexType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndexType -> ShowS
showsPrec :: Int -> IndexType -> ShowS
$cshow :: IndexType -> String
show :: IndexType -> String
$cshowList :: [IndexType] -> ShowS
showList :: [IndexType] -> ShowS
Show)

indexTypeCode :: IndexType -> H5_index_t
indexTypeCode :: IndexType -> H5_index_t
indexTypeCode IndexType
ByName            = H5_index_t
h5_INDEX_NAME
indexTypeCode IndexType
ByCreationOrder   = H5_index_t
h5_INDEX_CRT_ORDER

data IterOrder
    = Increasing
    | Decreasing
    | Native
    deriving (IterOrder -> IterOrder -> Bool
(IterOrder -> IterOrder -> Bool)
-> (IterOrder -> IterOrder -> Bool) -> Eq IterOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IterOrder -> IterOrder -> Bool
== :: IterOrder -> IterOrder -> Bool
$c/= :: IterOrder -> IterOrder -> Bool
/= :: IterOrder -> IterOrder -> Bool
Eq, Eq IterOrder
Eq IterOrder =>
(IterOrder -> IterOrder -> Ordering)
-> (IterOrder -> IterOrder -> Bool)
-> (IterOrder -> IterOrder -> Bool)
-> (IterOrder -> IterOrder -> Bool)
-> (IterOrder -> IterOrder -> Bool)
-> (IterOrder -> IterOrder -> IterOrder)
-> (IterOrder -> IterOrder -> IterOrder)
-> Ord IterOrder
IterOrder -> IterOrder -> Bool
IterOrder -> IterOrder -> Ordering
IterOrder -> IterOrder -> IterOrder
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 :: IterOrder -> IterOrder -> Ordering
compare :: IterOrder -> IterOrder -> Ordering
$c< :: IterOrder -> IterOrder -> Bool
< :: IterOrder -> IterOrder -> Bool
$c<= :: IterOrder -> IterOrder -> Bool
<= :: IterOrder -> IterOrder -> Bool
$c> :: IterOrder -> IterOrder -> Bool
> :: IterOrder -> IterOrder -> Bool
$c>= :: IterOrder -> IterOrder -> Bool
>= :: IterOrder -> IterOrder -> Bool
$cmax :: IterOrder -> IterOrder -> IterOrder
max :: IterOrder -> IterOrder -> IterOrder
$cmin :: IterOrder -> IterOrder -> IterOrder
min :: IterOrder -> IterOrder -> IterOrder
Ord, Int -> IterOrder
IterOrder -> Int
IterOrder -> [IterOrder]
IterOrder -> IterOrder
IterOrder -> IterOrder -> [IterOrder]
IterOrder -> IterOrder -> IterOrder -> [IterOrder]
(IterOrder -> IterOrder)
-> (IterOrder -> IterOrder)
-> (Int -> IterOrder)
-> (IterOrder -> Int)
-> (IterOrder -> [IterOrder])
-> (IterOrder -> IterOrder -> [IterOrder])
-> (IterOrder -> IterOrder -> [IterOrder])
-> (IterOrder -> IterOrder -> IterOrder -> [IterOrder])
-> Enum IterOrder
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 :: IterOrder -> IterOrder
succ :: IterOrder -> IterOrder
$cpred :: IterOrder -> IterOrder
pred :: IterOrder -> IterOrder
$ctoEnum :: Int -> IterOrder
toEnum :: Int -> IterOrder
$cfromEnum :: IterOrder -> Int
fromEnum :: IterOrder -> Int
$cenumFrom :: IterOrder -> [IterOrder]
enumFrom :: IterOrder -> [IterOrder]
$cenumFromThen :: IterOrder -> IterOrder -> [IterOrder]
enumFromThen :: IterOrder -> IterOrder -> [IterOrder]
$cenumFromTo :: IterOrder -> IterOrder -> [IterOrder]
enumFromTo :: IterOrder -> IterOrder -> [IterOrder]
$cenumFromThenTo :: IterOrder -> IterOrder -> IterOrder -> [IterOrder]
enumFromThenTo :: IterOrder -> IterOrder -> IterOrder -> [IterOrder]
Enum, IterOrder
IterOrder -> IterOrder -> Bounded IterOrder
forall a. a -> a -> Bounded a
$cminBound :: IterOrder
minBound :: IterOrder
$cmaxBound :: IterOrder
maxBound :: IterOrder
Bounded, ReadPrec [IterOrder]
ReadPrec IterOrder
Int -> ReadS IterOrder
ReadS [IterOrder]
(Int -> ReadS IterOrder)
-> ReadS [IterOrder]
-> ReadPrec IterOrder
-> ReadPrec [IterOrder]
-> Read IterOrder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IterOrder
readsPrec :: Int -> ReadS IterOrder
$creadList :: ReadS [IterOrder]
readList :: ReadS [IterOrder]
$creadPrec :: ReadPrec IterOrder
readPrec :: ReadPrec IterOrder
$creadListPrec :: ReadPrec [IterOrder]
readListPrec :: ReadPrec [IterOrder]
Read, Int -> IterOrder -> ShowS
[IterOrder] -> ShowS
IterOrder -> String
(Int -> IterOrder -> ShowS)
-> (IterOrder -> String)
-> ([IterOrder] -> ShowS)
-> Show IterOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IterOrder -> ShowS
showsPrec :: Int -> IterOrder -> ShowS
$cshow :: IterOrder -> String
show :: IterOrder -> String
$cshowList :: [IterOrder] -> ShowS
showList :: [IterOrder] -> ShowS
Show)

iterOrderCode :: IterOrder -> H5_iter_order_t
iterOrderCode :: IterOrder -> H5_iter_order_t
iterOrderCode IterOrder
Increasing = H5_iter_order_t
h5_ITER_INC
iterOrderCode IterOrder
Decreasing = H5_iter_order_t
h5_ITER_DEC
iterOrderCode IterOrder
Native     = H5_iter_order_t
h5_ITER_NATIVE