-- |
-- Module      : Foundation.Class.Storable
-- License     : BSD-style
-- Maintainer  : Haskell Foundation
-- Stability   : experimental
-- Portability : portable
--
-- <https://github.com/haskell-foundation/issues/111>
--
--

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE CPP #-}

module Foundation.Class.Storable
    ( Storable(..)
    , StorableFixed(..)

      -- * Ptr
    , Ptr, plusPtr, castPtr
      -- * offset based helper
    , peekOff, pokeOff
      -- * Collection
    , peekArray
    , peekArrayEndedBy
    , pokeArray
    , pokeArrayEndedBy
    ) where

#include "MachDeps.h"

import Foreign.Ptr (castPtr)
import qualified Foreign.Ptr
import qualified Foreign.Storable (peek, poke)

import Basement.Compat.Base
import Basement.Compat.C.Types (CChar, CUChar)
import Basement.Types.OffsetSize
import Basement.Types.Word128 (Word128(..))
import Basement.Types.Word256 (Word256(..))
import Foundation.Collection
import Foundation.Collection.Buildable (builderLift)
import Basement.PrimType
import Basement.Endianness
import Foundation.Numerical

-- | Storable type of self determined size.
--
class Storable a where
    peek :: Ptr a -> IO a
    poke :: Ptr a -> a -> IO ()

-- | Extending the Storable type class to the types that can be sequenced
-- in a structure.
--
class Storable a => StorableFixed a where
    size :: proxy a -> CountOf Word8
    alignment :: proxy a -> CountOf Word8

plusPtr :: StorableFixed a => Ptr a -> CountOf a -> Ptr a
plusPtr :: forall a. StorableFixed a => Ptr a -> CountOf a -> Ptr a
plusPtr Ptr a
ptr (CountOf Int
num) = Ptr a
ptr forall a b. Ptr a -> Int -> Ptr b
`Foreign.Ptr.plusPtr` (Int
num forall a. Multiplicative a => a -> a -> a
* (forall a (proxy :: * -> *).
StorableFixed a =>
proxy a -> CountOf Word8
size Ptr a
ptr forall {ty} {ty}. CountOf ty -> CountOf ty -> Int
`align` forall a (proxy :: * -> *).
StorableFixed a =>
proxy a -> CountOf Word8
alignment Ptr a
ptr))
  where
    align :: CountOf ty -> CountOf ty -> Int
align (CountOf Int
sz) (CountOf Int
a) = Int
sz forall a. Additive a => a -> a -> a
+ (Int
sz forall a. IDivisible a => a -> a -> a
`mod` Int
a)

-- | like `peek` but at a given offset.
peekOff :: StorableFixed a => Ptr a -> Offset a -> IO a
peekOff :: forall a. StorableFixed a => Ptr a -> Offset a -> IO a
peekOff Ptr a
ptr Offset a
off = forall a. Storable a => Ptr a -> IO a
peek (Ptr a
ptr forall a. StorableFixed a => Ptr a -> CountOf a -> Ptr a
`plusPtr` forall a. Offset a -> CountOf a
offsetAsSize Offset a
off)

-- | like `poke` but at a given offset.
pokeOff :: StorableFixed a => Ptr a -> Offset a -> a -> IO ()
pokeOff :: forall a. StorableFixed a => Ptr a -> Offset a -> a -> IO ()
pokeOff Ptr a
ptr Offset a
off = forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr a
ptr forall a. StorableFixed a => Ptr a -> CountOf a -> Ptr a
`plusPtr` forall a. Offset a -> CountOf a
offsetAsSize Offset a
off)

peekArray :: (Buildable col, StorableFixed (Element col))
          => CountOf (Element col) -> Ptr (Element col) -> IO col
peekArray :: forall col.
(Buildable col, StorableFixed (Element col)) =>
CountOf (Element col) -> Ptr (Element col) -> IO col
peekArray (CountOf Int
s) Ptr (Element col)
p = forall c (prim :: * -> *).
(Buildable c, PrimMonad prim) =>
Int -> Builder c (Mutable c) (Step c) prim () () -> prim c
build_ Int
64 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder Int
0 forall a b. (a -> b) -> a -> b
$ Ptr (Element col)
p
  where
    builder :: Int
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder Int
off Ptr (Element col)
ptr
      | Int
off forall a. Eq a => a -> a -> Bool
== Int
s = forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise = do
          Element col
v <- forall c (prim :: * -> *) a err.
(Buildable c, PrimMonad prim) =>
prim a -> Builder c (Mutable c) (Step c) prim err a
builderLift (forall a. StorableFixed a => Ptr a -> Offset a -> IO a
peekOff Ptr (Element col)
ptr (forall ty. Int -> Offset ty
Offset Int
off))
          forall col (prim :: * -> *) err.
(Buildable col, PrimMonad prim) =>
Element col -> Builder col (Mutable col) (Step col) prim err ()
append Element col
v
          Int
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder (Int
off forall a. Additive a => a -> a -> a
+ Int
1) Ptr (Element col)
ptr

peekArrayEndedBy :: (Buildable col, StorableFixed (Element col), Eq (Element col), Show (Element col))
                 => Element col -> Ptr (Element col) -> IO col
peekArrayEndedBy :: forall col.
(Buildable col, StorableFixed (Element col), Eq (Element col),
 Show (Element col)) =>
Element col -> Ptr (Element col) -> IO col
peekArrayEndedBy Element col
term Ptr (Element col)
p = forall c (prim :: * -> *).
(Buildable c, PrimMonad prim) =>
Int -> Builder c (Mutable c) (Step c) prim () () -> prim c
build_ Int
64 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Offset (Element col)
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder Offset (Element col)
0 forall a b. (a -> b) -> a -> b
$ Ptr (Element col)
p
  where
    builder :: Offset (Element col)
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder Offset (Element col)
off Ptr (Element col)
ptr = do
      Element col
v <- forall c (prim :: * -> *) a err.
(Buildable c, PrimMonad prim) =>
prim a -> Builder c (Mutable c) (Step c) prim err a
builderLift forall a b. (a -> b) -> a -> b
$ forall a. StorableFixed a => Ptr a -> Offset a -> IO a
peekOff Ptr (Element col)
ptr Offset (Element col)
off
      if Element col
term forall a. Eq a => a -> a -> Bool
== Element col
v
        then forall (m :: * -> *) a. Monad m => a -> m a
return ()
        else forall col (prim :: * -> *) err.
(Buildable col, PrimMonad prim) =>
Element col -> Builder col (Mutable col) (Step col) prim err ()
append Element col
v forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Offset (Element col)
-> Ptr (Element col)
-> Builder col (Mutable col) (Step col) IO () ()
builder (Offset (Element col)
off forall a. Additive a => a -> a -> a
+ (forall ty. Int -> Offset ty
Offset Int
1)) Ptr (Element col)
ptr

pokeArray :: (Sequential col, StorableFixed (Element col))
          => Ptr (Element col) -> col -> IO ()
pokeArray :: forall col.
(Sequential col, StorableFixed (Element col)) =>
Ptr (Element col) -> col -> IO ()
pokeArray Ptr (Element col)
ptr col
arr =
    forall (col :: * -> *) (m :: * -> *) a b.
(Mappable col, Applicative m, Monad m) =>
col a -> (a -> m b) -> m ()
forM_ (forall col.
(Sequential col, Collection col) =>
[Int] -> col -> [(Int, Element col)]
z [Int
0..] col
arr) forall a b. (a -> b) -> a -> b
$ \(Int
i, Element col
e) ->
        forall a. StorableFixed a => Ptr a -> Offset a -> a -> IO ()
pokeOff Ptr (Element col)
ptr (forall ty. Int -> Offset ty
Offset Int
i) Element col
e
  where
    z :: (Sequential col, Collection col) => [Int] -> col -> [(Int, Element col)]
    z :: forall col.
(Sequential col, Collection col) =>
[Int] -> col -> [(Int, Element col)]
z = forall col a b.
(BoxedZippable col, Sequential a, Sequential b,
 Element col ~ (Element a, Element b)) =>
a -> b -> col
zip

pokeArrayEndedBy :: (Sequential col, StorableFixed (Element col))
                 => Element col -> Ptr (Element col) -> col -> IO ()
pokeArrayEndedBy :: forall col.
(Sequential col, StorableFixed (Element col)) =>
Element col -> Ptr (Element col) -> col -> IO ()
pokeArrayEndedBy Element col
term Ptr (Element col)
ptr col
col = do
    forall col.
(Sequential col, StorableFixed (Element col)) =>
Ptr (Element col) -> col -> IO ()
pokeArray Ptr (Element col)
ptr col
col
    forall a. StorableFixed a => Ptr a -> Offset a -> a -> IO ()
pokeOff Ptr (Element col)
ptr (forall a. CountOf a -> Offset a
sizeAsOffset forall a b. (a -> b) -> a -> b
$ forall c. Collection c => c -> CountOf (Element c)
length col
col) Element col
term

instance Storable CChar where
    peek :: Ptr CChar -> IO CChar
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr CChar -> CChar -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable CUChar where
    peek :: Ptr CUChar -> IO CUChar
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr CUChar -> CUChar -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Char where
    peek :: Ptr Char -> IO Char
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Char -> Char -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Double where
    peek :: Ptr Double -> IO Double
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Double -> Double -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Float where
    peek :: Ptr Float -> IO Float
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Float -> Float -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Int8 where
    peek :: Ptr Int8 -> IO Int8
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Int8 -> Int8 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Int16 where
    peek :: Ptr Int16 -> IO Int16
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Int16 -> Int16 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Int32 where
    peek :: Ptr Int32 -> IO Int32
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Int32 -> Int32 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Int64 where
    peek :: Ptr Int64 -> IO Int64
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Int64 -> Int64 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Word8 where
    peek :: Ptr Word8 -> IO Word8
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word8 -> Word8 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable Word16 where
    peek :: Ptr Word16 -> IO Word16
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word16 -> Word16 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable (BE Word16) where
    peek :: Ptr (BE Word16) -> IO (BE Word16)
peek (Ptr Addr#
addr) = forall a. a -> BE a
BE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (BE Word16) -> BE Word16 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. BE a -> a
unBE
instance Storable (LE Word16) where
    peek :: Ptr (LE Word16) -> IO (LE Word16)
peek (Ptr Addr#
addr) = forall a. a -> LE a
LE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (LE Word16) -> LE Word16 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. LE a -> a
unLE
instance Storable Word32 where
    peek :: Ptr Word32 -> IO Word32
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word32 -> Word32 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable (BE Word32) where
    peek :: Ptr (BE Word32) -> IO (BE Word32)
peek (Ptr Addr#
addr) = forall a. a -> BE a
BE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (BE Word32) -> BE Word32 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. BE a -> a
unBE
instance Storable (LE Word32) where
    peek :: Ptr (LE Word32) -> IO (LE Word32)
peek (Ptr Addr#
addr) = forall a. a -> LE a
LE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (LE Word32) -> LE Word32 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. LE a -> a
unLE
instance Storable Word64 where
    peek :: Ptr Word64 -> IO Word64
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word64 -> Word64 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable (BE Word64) where
    peek :: Ptr (BE Word64) -> IO (BE Word64)
peek (Ptr Addr#
addr) = forall a. a -> BE a
BE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (BE Word64) -> BE Word64 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. BE a -> a
unBE
instance Storable (LE Word64) where
    peek :: Ptr (LE Word64) -> IO (LE Word64)
peek (Ptr Addr#
addr) = forall a. a -> LE a
LE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (LE Word64) -> LE Word64 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. LE a -> a
unLE
instance Storable Word128 where
    peek :: Ptr Word128 -> IO Word128
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word128 -> Word128 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable (BE Word128) where
    peek :: Ptr (BE Word128) -> IO (BE Word128)
peek (Ptr Addr#
addr) = forall a. a -> BE a
BE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (BE Word128) -> BE Word128 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. BE a -> a
unBE
instance Storable (LE Word128) where
    peek :: Ptr (LE Word128) -> IO (LE Word128)
peek (Ptr Addr#
addr) = forall a. a -> LE a
LE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (LE Word128) -> LE Word128 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. LE a -> a
unLE
instance Storable Word256 where
    peek :: Ptr Word256 -> IO Word256
peek (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr Word256 -> Word256 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
instance Storable (BE Word256) where
    peek :: Ptr (BE Word256) -> IO (BE Word256)
peek (Ptr Addr#
addr) = forall a. a -> BE a
BE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (BE Word256) -> BE Word256 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. BE a -> a
unBE
instance Storable (LE Word256) where
    peek :: Ptr (LE Word256) -> IO (LE Word256)
peek (Ptr Addr#
addr) = forall a. a -> LE a
LE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> prim ty
primAddrRead Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0)
    poke :: Ptr (LE Word256) -> LE Word256 -> IO ()
poke (Ptr Addr#
addr) = forall ty (prim :: * -> *).
(PrimType ty, PrimMonad prim) =>
Addr# -> Offset ty -> ty -> prim ()
primAddrWrite Addr#
addr (forall ty. Int -> Offset ty
Offset Int
0) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. LE a -> a
unLE
instance Storable (Ptr a) where
    peek :: Ptr (Ptr a) -> IO (Ptr a)
peek = forall a. Storable a => Ptr a -> IO a
Foreign.Storable.peek
    poke :: Ptr (Ptr a) -> Ptr a -> IO ()
poke = forall a. Storable a => Ptr a -> a -> IO ()
Foreign.Storable.poke

instance StorableFixed CChar where
    size :: forall (proxy :: * -> *). proxy CChar -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_CHAR
    alignment :: forall (proxy :: * -> *). proxy CChar -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_CHAR
instance StorableFixed CUChar where
    size :: forall (proxy :: * -> *). proxy CUChar -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD8
    alignment :: forall (proxy :: * -> *). proxy CUChar -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD8
instance StorableFixed Char where
    size :: forall (proxy :: * -> *). proxy Char -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_HSCHAR
    alignment :: forall (proxy :: * -> *). proxy Char -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_HSCHAR
instance StorableFixed Double where
    size :: forall (proxy :: * -> *). proxy Double -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_HSDOUBLE
    alignment :: forall (proxy :: * -> *). proxy Double -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_HSDOUBLE
instance StorableFixed Float where
    size :: forall (proxy :: * -> *). proxy Float -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_HSFLOAT
    alignment :: forall (proxy :: * -> *). proxy Float -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_HSFLOAT
instance StorableFixed Int8 where
    size :: forall (proxy :: * -> *). proxy Int8 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_INT8
    alignment :: forall (proxy :: * -> *). proxy Int8 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_INT8
instance StorableFixed Int16 where
    size :: forall (proxy :: * -> *). proxy Int16 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_INT16
    alignment :: forall (proxy :: * -> *). proxy Int16 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_INT16
instance StorableFixed Int32 where
    size :: forall (proxy :: * -> *). proxy Int32 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_INT32
    alignment :: forall (proxy :: * -> *). proxy Int32 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_INT32
instance StorableFixed Int64 where
    size :: forall (proxy :: * -> *). proxy Int64 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_INT64
    alignment :: forall (proxy :: * -> *). proxy Int64 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_INT64
instance StorableFixed Word8 where
    size :: forall (proxy :: * -> *). proxy Word8 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD8
    alignment :: forall (proxy :: * -> *). proxy Word8 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD8
instance StorableFixed Word16 where
    size :: forall (proxy :: * -> *). proxy Word16 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD16
    alignment :: forall (proxy :: * -> *). proxy Word16 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD16
instance StorableFixed (BE Word16) where
    size :: forall (proxy :: * -> *). proxy (BE Word16) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD16
    alignment :: forall (proxy :: * -> *). proxy (BE Word16) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD16
instance StorableFixed (LE Word16) where
    size :: forall (proxy :: * -> *). proxy (LE Word16) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD16
    alignment :: forall (proxy :: * -> *). proxy (LE Word16) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD16
instance StorableFixed Word32 where
    size :: forall (proxy :: * -> *). proxy Word32 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD32
    alignment :: forall (proxy :: * -> *). proxy Word32 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD32
instance StorableFixed (BE Word32) where
    size :: forall (proxy :: * -> *). proxy (BE Word32) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD32
    alignment :: forall (proxy :: * -> *). proxy (BE Word32) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD32
instance StorableFixed (LE Word32) where
    size :: forall (proxy :: * -> *). proxy (LE Word32) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD32
    alignment :: forall (proxy :: * -> *). proxy (LE Word32) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD32
instance StorableFixed Word64 where
    size :: forall (proxy :: * -> *). proxy Word64 -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD64
    alignment :: forall (proxy :: * -> *). proxy Word64 -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD64
instance StorableFixed (BE Word64) where
    size :: forall (proxy :: * -> *). proxy (BE Word64) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD64
    alignment :: forall (proxy :: * -> *). proxy (BE Word64) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD64
instance StorableFixed (LE Word64) where
    size :: forall (proxy :: * -> *). proxy (LE Word64) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_WORD64
    alignment :: forall (proxy :: * -> *). proxy (LE Word64) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_WORD64
instance StorableFixed Word128 where
    size :: forall (proxy :: * -> *). proxy Word128 -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
16
    alignment :: forall (proxy :: * -> *). proxy Word128 -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
16
instance StorableFixed (BE Word128) where
    size :: forall (proxy :: * -> *). proxy (BE Word128) -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
16
    alignment :: forall (proxy :: * -> *). proxy (BE Word128) -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
16
instance StorableFixed (LE Word128) where
    size :: forall (proxy :: * -> *). proxy (LE Word128) -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
16
    alignment :: forall (proxy :: * -> *). proxy (LE Word128) -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
16
instance StorableFixed Word256 where
    size :: forall (proxy :: * -> *). proxy Word256 -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
32
    alignment :: forall (proxy :: * -> *). proxy Word256 -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
32
instance StorableFixed (BE Word256) where
    size :: forall (proxy :: * -> *). proxy (BE Word256) -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
32
    alignment :: forall (proxy :: * -> *). proxy (BE Word256) -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
32
instance StorableFixed (LE Word256) where
    size :: forall (proxy :: * -> *). proxy (LE Word256) -> CountOf Word8
size      = forall a b. a -> b -> a
const CountOf Word8
32
    alignment :: forall (proxy :: * -> *). proxy (LE Word256) -> CountOf Word8
alignment = forall a b. a -> b -> a
const CountOf Word8
32
instance StorableFixed (Ptr a) where
    size :: forall (proxy :: * -> *). proxy (Ptr a) -> CountOf Word8
size      = forall a b. a -> b -> a
const SIZEOF_HSPTR
    alignment :: forall (proxy :: * -> *). proxy (Ptr a) -> CountOf Word8
alignment = forall a b. a -> b -> a
const ALIGNMENT_HSPTR