Haskus.Format.Binary.Storable

Storable class

Documentation

class StaticStorable a where

A storable data in constant space whose size is known at compile time

Minimal complete definition

staticPeekIO, staticPokeIO

Associated Types

type SizeOf a :: Nat

Size of the stored data (in bytes)

type Alignment a :: Nat

Alignment requirement (in bytes)

Methods

staticPeekIO :: Ptr a -> IO a

Peek (read) a value from a memory address

staticPokeIO :: Ptr a -> a -> IO ()

Poke (write) a value at the given memory address

Instances

StaticStorable Int8

Associated Types

type SizeOf Int8 :: Nat

type Alignment Int8 :: Nat

Methods

staticPeekIO :: Ptr Int8 -> IO Int8

staticPokeIO :: Ptr Int8 -> Int8 -> IO ()

StaticStorable Int16

Associated Types

type SizeOf Int16 :: Nat

type Alignment Int16 :: Nat

Methods

staticPeekIO :: Ptr Int16 -> IO Int16

staticPokeIO :: Ptr Int16 -> Int16 -> IO ()

StaticStorable Int32

Associated Types

type SizeOf Int32 :: Nat

type Alignment Int32 :: Nat

Methods

staticPeekIO :: Ptr Int32 -> IO Int32

staticPokeIO :: Ptr Int32 -> Int32 -> IO ()

StaticStorable Int64

Associated Types

type SizeOf Int64 :: Nat

type Alignment Int64 :: Nat

Methods

staticPeekIO :: Ptr Int64 -> IO Int64

staticPokeIO :: Ptr Int64 -> Int64 -> IO ()

StaticStorable Word8

Associated Types

type SizeOf Word8 :: Nat

type Alignment Word8 :: Nat

Methods

staticPeekIO :: Ptr Word8 -> IO Word8

staticPokeIO :: Ptr Word8 -> Word8 -> IO ()

StaticStorable Word16

Associated Types

type SizeOf Word16 :: Nat

type Alignment Word16 :: Nat

Methods

staticPeekIO :: Ptr Word16 -> IO Word16

staticPokeIO :: Ptr Word16 -> Word16 -> IO ()

StaticStorable Word32

Associated Types

type SizeOf Word32 :: Nat

type Alignment Word32 :: Nat

Methods

staticPeekIO :: Ptr Word32 -> IO Word32

staticPokeIO :: Ptr Word32 -> Word32 -> IO ()

StaticStorable Word64

Associated Types

type SizeOf Word64 :: Nat

type Alignment Word64 :: Nat

Methods

staticPeekIO :: Ptr Word64 -> IO Word64

staticPokeIO :: Ptr Word64 -> Word64 -> IO ()

((~) Nat s (FullRecordSize fs), KnownNat s) => StaticStorable (Record fs)

Associated Types

type SizeOf (Record fs) :: Nat

type Alignment (Record fs) :: Nat

Methods

staticPeekIO :: Ptr (Record fs) -> IO (Record fs)

staticPokeIO :: Ptr (Record fs) -> Record fs -> IO ()

(KnownNat (Max (MapSizeOf fs)), KnownNat (Max (MapAlignment fs))) => StaticStorable (Union fs)

Associated Types

type SizeOf (Union fs) :: Nat

type Alignment (Union fs) :: Nat

Methods

staticPeekIO :: Ptr (Union fs) -> IO (Union fs)

staticPokeIO :: Ptr (Union fs) -> Union fs -> IO ()

(ByteReversable a, StaticStorable a) => StaticStorable (AsLittleEndian a)

Associated Types

type SizeOf (AsLittleEndian a) :: Nat

type Alignment (AsLittleEndian a) :: Nat

Methods

staticPeekIO :: Ptr (AsLittleEndian a) -> IO (AsLittleEndian a)

staticPokeIO :: Ptr (AsLittleEndian a) -> AsLittleEndian a -> IO ()

(ByteReversable a, StaticStorable a) => StaticStorable (AsBigEndian a)

Associated Types

type SizeOf (AsBigEndian a) :: Nat

type Alignment (AsBigEndian a) :: Nat

Methods

staticPeekIO :: Ptr (AsBigEndian a) -> IO (AsBigEndian a)

staticPokeIO :: Ptr (AsBigEndian a) -> AsBigEndian a -> IO ()

(Integral b, StaticStorable b, CEnum a) => StaticStorable (EnumField b a)

Associated Types

type SizeOf (EnumField b a) :: Nat

type Alignment (EnumField b a) :: Nat

Methods

staticPeekIO :: Ptr (EnumField b a) -> IO (EnumField b a)

staticPokeIO :: Ptr (EnumField b a) -> EnumField b a -> IO ()

KnownNat (* (SizeOf a) n) => StaticStorable (Vector n a)

Associated Types

type SizeOf (Vector n a) :: Nat

type Alignment (Vector n a) :: Nat

Methods

staticPeekIO :: Ptr (Vector n a) -> IO (Vector n a)

staticPokeIO :: Ptr (Vector n a) -> Vector n a -> IO ()

staticPeek :: (StaticStorable a, MonadIO m) => Ptr a -> m a

Peek (read) a value from a memory address

staticPoke :: (StaticStorable a, MonadIO m) => Ptr a -> a -> m ()

Poke (write) a value at the given memory address

type family RequiredPadding a b where ...

Compute the required padding between a and b to respect b's alignment

Equations

RequiredPadding a b = Padding (SizeOf a) b

type family Padding (sz :: Nat) b where ...

Compute the required padding between the size sz and b to respect b's alignment

Equations

Padding sz b = PaddingEx (Modulo sz (Alignment b)) (Alignment b)

type family PaddingEx (m :: Nat) (a :: Nat) where ...

Equations

PaddingEx 0 a = 0

PaddingEx m a = a - m

staticSizeOf :: forall a. KnownNat (SizeOf a) => a -> Word

Get statically known size

staticAlignment :: forall a. KnownNat (Alignment a) => a -> Word

Get statically known alignment

wordBytes :: forall a. (Storable a, KnownNat (SizeOf a)) => a -> [Word8]

Get bytes in host-endianness order

Storable

class Storable a where

Storable data-types

Currently we cannot automatically derive a Storable class with type-level naturals for "alignment" and "sizeOf". Instead we define a Storable class isomorphic to the Foreign.Storable's one but with default methods using DefaultSignatures (i.e., the Storable instance can be automatically derived from a Generic instance).

Methods

peekIO :: Ptr a -> IO a

peekIO :: (Generic a, GStorable (Rep a)) => Ptr a -> IO a

pokeIO :: Ptr a -> a -> IO ()

pokeIO :: (Generic a, GStorable (Rep a)) => Ptr a -> a -> IO ()

alignment :: a -> Word

alignment :: (Generic a, GStorable (Rep a)) => a -> Word

sizeOf :: a -> Word

sizeOf :: (Generic a, GStorable (Rep a)) => a -> Word

Instances

Storable Char

Methods

peekIO :: Ptr Char -> IO Char

pokeIO :: Ptr Char -> Char -> IO ()

alignment :: Char -> Word

sizeOf :: Char -> Word

Storable Double

Methods

peekIO :: Ptr Double -> IO Double

pokeIO :: Ptr Double -> Double -> IO ()

alignment :: Double -> Word

sizeOf :: Double -> Word

Storable Float

Methods

peekIO :: Ptr Float -> IO Float

pokeIO :: Ptr Float -> Float -> IO ()

alignment :: Float -> Word

sizeOf :: Float -> Word

Storable Int

Methods

peekIO :: Ptr Int -> IO Int

pokeIO :: Ptr Int -> Int -> IO ()

alignment :: Int -> Word

sizeOf :: Int -> Word

Storable Int8

Methods

peekIO :: Ptr Int8 -> IO Int8

pokeIO :: Ptr Int8 -> Int8 -> IO ()

alignment :: Int8 -> Word

sizeOf :: Int8 -> Word

Storable Int16

Methods

peekIO :: Ptr Int16 -> IO Int16

pokeIO :: Ptr Int16 -> Int16 -> IO ()

alignment :: Int16 -> Word

sizeOf :: Int16 -> Word

Storable Int32

Methods

peekIO :: Ptr Int32 -> IO Int32

pokeIO :: Ptr Int32 -> Int32 -> IO ()

alignment :: Int32 -> Word

sizeOf :: Int32 -> Word

Storable Int64

Methods

peekIO :: Ptr Int64 -> IO Int64

pokeIO :: Ptr Int64 -> Int64 -> IO ()

alignment :: Int64 -> Word

sizeOf :: Int64 -> Word

Storable Word

Methods

peekIO :: Ptr Word -> IO Word

pokeIO :: Ptr Word -> Word -> IO ()

alignment :: Word -> Word

sizeOf :: Word -> Word

Storable Word8

Methods

peekIO :: Ptr Word8 -> IO Word8

pokeIO :: Ptr Word8 -> Word8 -> IO ()

alignment :: Word8 -> Word

sizeOf :: Word8 -> Word

Storable Word16

Methods

peekIO :: Ptr Word16 -> IO Word16

pokeIO :: Ptr Word16 -> Word16 -> IO ()

alignment :: Word16 -> Word

sizeOf :: Word16 -> Word

Storable Word32

Methods

peekIO :: Ptr Word32 -> IO Word32

pokeIO :: Ptr Word32 -> Word32 -> IO ()

alignment :: Word32 -> Word

sizeOf :: Word32 -> Word

Storable Word64

Methods

peekIO :: Ptr Word64 -> IO Word64

pokeIO :: Ptr Word64 -> Word64 -> IO ()

alignment :: Word64 -> Word

sizeOf :: Word64 -> Word

Storable WordPtr

Methods

peekIO :: Ptr WordPtr -> IO WordPtr

pokeIO :: Ptr WordPtr -> WordPtr -> IO ()

alignment :: WordPtr -> Word

sizeOf :: WordPtr -> Word

Storable CChar

Methods

peekIO :: Ptr CChar -> IO CChar

pokeIO :: Ptr CChar -> CChar -> IO ()

alignment :: CChar -> Word

sizeOf :: CChar -> Word

Storable CShort

Methods

peekIO :: Ptr CShort -> IO CShort

pokeIO :: Ptr CShort -> CShort -> IO ()

alignment :: CShort -> Word

sizeOf :: CShort -> Word

Storable CUShort

Methods

peekIO :: Ptr CUShort -> IO CUShort

pokeIO :: Ptr CUShort -> CUShort -> IO ()

alignment :: CUShort -> Word

sizeOf :: CUShort -> Word

Storable CInt

Methods

peekIO :: Ptr CInt -> IO CInt

pokeIO :: Ptr CInt -> CInt -> IO ()

alignment :: CInt -> Word

sizeOf :: CInt -> Word

Storable CUInt

Methods

peekIO :: Ptr CUInt -> IO CUInt

pokeIO :: Ptr CUInt -> CUInt -> IO ()

alignment :: CUInt -> Word

sizeOf :: CUInt -> Word

Storable CLong

Methods

peekIO :: Ptr CLong -> IO CLong

pokeIO :: Ptr CLong -> CLong -> IO ()

alignment :: CLong -> Word

sizeOf :: CLong -> Word

Storable CULong

Methods

peekIO :: Ptr CULong -> IO CULong

pokeIO :: Ptr CULong -> CULong -> IO ()

alignment :: CULong -> Word

sizeOf :: CULong -> Word

Storable CSize

Methods

peekIO :: Ptr CSize -> IO CSize

pokeIO :: Ptr CSize -> CSize -> IO ()

alignment :: CSize -> Word

sizeOf :: CSize -> Word

Storable (Ptr a)

Methods

peekIO :: Ptr (Ptr a) -> IO (Ptr a)

pokeIO :: Ptr (Ptr a) -> Ptr a -> IO ()

alignment :: Ptr a -> Word

sizeOf :: Ptr a -> Word

(HFoldr' FoldSizeOf Word l Word, HFoldr' FoldAlignment Word l Word) => Storable (Union l)

Methods

peekIO :: Ptr (Union l) -> IO (Union l)

pokeIO :: Ptr (Union l) -> Union l -> IO ()

alignment :: Union l -> Word

sizeOf :: Union l -> Word

(ByteReversable a, Storable a) => Storable (AsLittleEndian a)

Methods

peekIO :: Ptr (AsLittleEndian a) -> IO (AsLittleEndian a)

pokeIO :: Ptr (AsLittleEndian a) -> AsLittleEndian a -> IO ()

alignment :: AsLittleEndian a -> Word

sizeOf :: AsLittleEndian a -> Word

(ByteReversable a, Storable a) => Storable (AsBigEndian a)

Methods

peekIO :: Ptr (AsBigEndian a) -> IO (AsBigEndian a)

pokeIO :: Ptr (AsBigEndian a) -> AsBigEndian a -> IO ()

alignment :: AsBigEndian a -> Word

sizeOf :: AsBigEndian a -> Word

(Storable b, Integral b, CEnum a) => Storable (EnumField b a)

Methods

peekIO :: Ptr (EnumField b a) -> IO (EnumField b a)

pokeIO :: Ptr (EnumField b a) -> EnumField b a -> IO ()

alignment :: EnumField b a -> Word

sizeOf :: EnumField b a -> Word

(KnownNat n, Storable a) => Storable (Vector n a)

Methods

peekIO :: Ptr (Vector n a) -> IO (Vector n a)

pokeIO :: Ptr (Vector n a) -> Vector n a -> IO ()

alignment :: Vector n a -> Word

sizeOf :: Vector n a -> Word

Storable b => Storable (BitSet b a)

Methods

peekIO :: Ptr (BitSet b a) -> IO (BitSet b a)

pokeIO :: Ptr (BitSet b a) -> BitSet b a -> IO ()

alignment :: BitSet b a -> Word

sizeOf :: BitSet b a -> Word

Storable b => Storable (BitFields b f)

Methods

peekIO :: Ptr (BitFields b f) -> IO (BitFields b f)

pokeIO :: Ptr (BitFields b f) -> BitFields b f -> IO ()

alignment :: BitFields b f -> Word

sizeOf :: BitFields b f -> Word

Storable s => Storable (BitField n name s)

Methods

peekIO :: Ptr (BitField n name s) -> IO (BitField n name s)

pokeIO :: Ptr (BitField n name s) -> BitField n name s -> IO ()

alignment :: BitField n name s -> Word

sizeOf :: BitField n name s -> Word

Storable w => Storable (FixedPoint w i f)

Methods

peekIO :: Ptr (FixedPoint w i f) -> IO (FixedPoint w i f)

pokeIO :: Ptr (FixedPoint w i f) -> FixedPoint w i f -> IO ()

alignment :: FixedPoint w i f -> Word

sizeOf :: FixedPoint w i f -> Word

peek :: (Storable a, MonadIO m) => Ptr a -> m a

Peek a value from a pointer

poke :: (Storable a, MonadIO m) => Ptr a -> a -> m ()

Poke a value to a pointer

sizeOf' :: (Integral b, Storable a) => a -> b

Generalized sizeOf

sizeOfT :: forall a. Storable a => Word

SizeOf (for type-application)

sizeOfT' :: forall a b. (Storable a, Integral b) => b

SizeOf' (for type-application)

alignment' :: (Integral b, Storable a) => a -> b

Generalized alignment

alignmentT :: forall a. Storable a => Word

Alignment (for type-application)

alignmentT' :: forall a b. (Storable a, Integral b) => b

Alignment' (for type-application)

peekByteOff :: (MonadIO m, Storable a) => Ptr a -> Int -> m a

Peek with byte offset

pokeByteOff :: (MonadIO m, Storable a) => Ptr a -> Int -> a -> m ()

Poke with byte offset

peekElemOff :: forall a m. (MonadIO m, Storable a) => Ptr a -> Int -> m a

Peek with element size offset

pokeElemOff :: (MonadIO m, Storable a) => Ptr a -> Int -> a -> m ()

Poke with element size offset

alloca :: forall a b m. (MonadInIO m, Storable a) => (Ptr a -> m b) -> m b

alloca f executes the computation f, passing as argument a pointer to a temporarily allocated block of memory sufficient to hold values of type a.

The memory is freed when f terminates (either normally or via an exception), so the pointer passed to f must not be used after this.

allocaBytes :: MonadInIO m => Word -> (Ptr a -> m b) -> m b

Allocate some bytes

allocaBytesAligned :: MonadInIO m => Word -> Word -> (Ptr a -> m b) -> m b

Allocate some aligned bytes

malloc :: forall a m. (MonadIO m, Storable a) => m (Ptr a)

Allocate a block of memory that is sufficient to hold values of type a. The size of the area allocated is determined by the sizeOf method from the instance of Storable for the appropriate type.

The memory may be deallocated using free or finalizerFree when no longer required.

with :: (MonadInIO m, Storable a) => a -> (Ptr a -> m b) -> m b

with val f executes the computation f, passing as argument a pointer to a temporarily allocated block of memory into which val has been marshalled (the combination of alloca and poke).

The memory is freed when f terminates (either normally or via an exception), so the pointer passed to f must not be used after this.

withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res

Replicates a withXXX combinator over a list of objects, yielding a list of marshalled objects

allocaArray :: forall a b m. (MonadInIO m, Storable a) => Word -> (Ptr a -> m b) -> m b

Temporarily allocate space for the given number of elements (like alloca, but for multiple elements).

mallocArray :: forall a m. (MonadIO m, Storable a) => Word -> m (Ptr a)

Allocate space for the given number of elements (like malloc, but for multiple elements).

withArray :: (MonadInIO m, Storable a) => [a] -> (Ptr a -> m b) -> m b

Temporarily store a list of storable values in memory (like with, but for multiple elements).

withArrayLen :: (MonadInIO m, Storable a) => [a] -> (Word -> Ptr a -> m b) -> m b

Like withArray, but the action gets the number of values as an additional parameter

peekArray :: (MonadIO m, Storable a) => Word -> Ptr a -> m [a]

Convert an array of given length into a Haskell list. The implementation is tail-recursive and so uses constant stack space.

pokeArray :: (MonadIO m, Storable a) => Ptr a -> [a] -> m ()

Write the list elements consecutive into memory