{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedRecordDot #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoFieldSelectors #-}

module Data.Persist
  ( -- * The Persist class
    Persist (..)

    -- * Endianness
  , HostEndian
  , BigEndian (..)
  , LittleEndian (..)

    -- * Helpers for writing Persist instances
  , HasEndianness (..)
  , ReinterpretAs (..)
  , SerializeAs (..)
  , ViaReinterpretAs (..)
  , ViaSerializeAs (..)

    -- * Serialization
  , encode
  , encodeLazy
  , decode

    -- * The Get type
  , Get
  , runGet
  , ensure
  , skip
  , getBytes
  , getByteString
  , remaining
  , eof
  , getPrefix
  , getHE
  , getLE
  , getBE

    -- * The Put type
  , Put
  , runPut
  , runPutLazy
  , evalPut
  , evalPutLazy
  , grow
  , putByteString
  , putHE
  , putLE
  , putBE

    -- * Size Reserve/Resolve
  , reserveSize
  , resolveSizeExclusiveBE
  , resolveSizeExclusiveLE
  , resolveSizeInclusiveBE
  , resolveSizeInclusiveLE
  , resolveSizeLE
  , resolveSizeBE
  ) where

import Control.Exception (throw)
import Control.Monad (forM_, when, (<$!>))
import Data.Bits (Bits (..))
import Data.ByteString (ByteString)
import Data.IORef (readIORef)
import Data.Int (Int16, Int32, Int64, Int8)
import Data.IntMap (IntMap)
import Data.IntSet (IntSet)
import Data.Kind (Constraint, Type)
import Data.List (unfoldr)
import Data.List.NonEmpty (NonEmpty (..))
import Data.Map (Map)
import Data.Persist.Internal
import Data.Proxy
import Data.Sequence (Seq)
import Data.Set (Set)
import Data.Text (Text)
#ifdef UNALIGNED_MEMORY
import Data.Word (Word8, Word16, Word32, Word64, byteSwap16, byteSwap32, byteSwap64)
#else
import Data.Word (Word8, Word16, Word32, Word64)
#endif
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as B
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Short as S
import qualified Data.ByteString.Short.Internal as S
import qualified Data.Monoid as M
import qualified Data.Text.Encoding as TE
import qualified Data.Tree as T
import Foreign (Ptr, Storable (..), castPtr, minusPtr, plusPtr, withForeignPtr)
import Foreign.Marshal.Utils (copyBytes)
import GHC.Base (ord, unsafeChr)
import GHC.Exts (IsList (..))
import GHC.Generics
import GHC.Real (Ratio (..))
import GHC.TypeLits
  ( ErrorMessage (..)
  , KnownNat
  , Nat
  , Natural
  , Symbol
  , TypeError
  , natVal
  , type (+)
  , type (<=?)
  )

#include "MachDeps.h"

putHE :: (Persist (HostEndian a)) => a -> Put ()
getHE :: (Persist (HostEndian a)) => Get a
{-# INLINE putHE #-}
{-# INLINE getHE #-}

#ifdef WORDS_BIGENDIAN
type HostEndian = BigEndian
getHE = getBE
putHE = putBE
#else
type HostEndian = LittleEndian
getHE :: forall a. Persist (HostEndian a) => Get a
getHE = Get a
forall a. Persist (HostEndian a) => Get a
getLE
putHE :: forall a. Persist (HostEndian a) => a -> Put ()
putHE = a -> Put ()
forall a. Persist (HostEndian a) => a -> Put ()
putLE
#endif

poke16LE :: Ptr Word8 -> Word16 -> IO ()
poke32LE :: Ptr Word8 -> Word32 -> IO ()
poke64LE :: Ptr Word8 -> Word64 -> IO ()
{-# INLINE poke16LE #-}
{-# INLINE poke32LE #-}
{-# INLINE poke64LE #-}

poke16BE :: Ptr Word8 -> Word16 -> IO ()
poke32BE :: Ptr Word8 -> Word32 -> IO ()
poke64BE :: Ptr Word8 -> Word64 -> IO ()
{-# INLINE poke16BE #-}
{-# INLINE poke32BE #-}
{-# INLINE poke64BE #-}

peek16LE :: Ptr Word8 -> IO Word16
peek32LE :: Ptr Word8 -> IO Word32
peek64LE :: Ptr Word8 -> IO Word64
{-# INLINE peek16LE #-}
{-# INLINE peek32LE #-}
{-# INLINE peek64LE #-}

peek16BE :: Ptr Word8 -> IO Word16
peek32BE :: Ptr Word8 -> IO Word32
peek64BE :: Ptr Word8 -> IO Word64
{-# INLINE peek16BE #-}
{-# INLINE peek32BE #-}
{-# INLINE peek64BE #-}

#ifndef UNALIGNED_MEMORY
pokeByte :: (Integral a) => Ptr Word8 -> a -> IO ()
pokeByte p x = poke p (fromIntegral x)
{-# INLINE pokeByte #-}

peekByte :: (Integral a) => Ptr Word8 -> IO a
peekByte p = do
  !b <- peek p
  return $! fromIntegral b
{-# INLINE peekByte #-}

poke16LE p y = do
  pokeByte p y
  pokeByte (p `plusPtr` 1) $ y `unsafeShiftR` 8

poke16BE p y = do
  pokeByte p $ y `unsafeShiftR` 8
  pokeByte (p `plusPtr` 1) y

poke32LE p y = do
  pokeByte p y
  pokeByte (p `plusPtr` 1) $ y `unsafeShiftR` 8
  pokeByte (p `plusPtr` 2) $ y `unsafeShiftR` 16
  pokeByte (p `plusPtr` 3) $ y `unsafeShiftR` 24

poke32BE p y = do
  pokeByte p $ y `unsafeShiftR` 24
  pokeByte (p `plusPtr` 1) $ y `unsafeShiftR` 16
  pokeByte (p `plusPtr` 2) $ y `unsafeShiftR` 8
  pokeByte (p `plusPtr` 3) y

poke64LE p y = do
  pokeByte p y
  pokeByte (p `plusPtr` 1) $ y `unsafeShiftR` 8
  pokeByte (p `plusPtr` 2) $ y `unsafeShiftR` 16
  pokeByte (p `plusPtr` 3) $ y `unsafeShiftR` 24
  pokeByte (p `plusPtr` 4) $ y `unsafeShiftR` 32
  pokeByte (p `plusPtr` 5) $ y `unsafeShiftR` 40
  pokeByte (p `plusPtr` 6) $ y `unsafeShiftR` 48
  pokeByte (p `plusPtr` 7) $ y `unsafeShiftR` 56

poke64BE p y = do
  pokeByte p $ y `unsafeShiftR` 56
  pokeByte (p `plusPtr` 1) $ y `unsafeShiftR` 48
  pokeByte (p `plusPtr` 2) $ y `unsafeShiftR` 40
  pokeByte (p `plusPtr` 3) $ y `unsafeShiftR` 32
  pokeByte (p `plusPtr` 4) $ y `unsafeShiftR` 24
  pokeByte (p `plusPtr` 5) $ y `unsafeShiftR` 16
  pokeByte (p `plusPtr` 6) $ y `unsafeShiftR` 8
  pokeByte (p `plusPtr` 7) y

peek16LE p = do
  !x0 <- peekByte @Word16 p
  !x1 <- peekByte @Word16 (p `plusPtr` 1)
  return $ x1 `unsafeShiftL` 8
    .|. x0

peek16BE p = do
  !x0 <- peekByte @Word16 p
  !x1 <- peekByte @Word16 (p `plusPtr` 1)
  return $ x0 `unsafeShiftL` 8
    .|. x1

peek32LE p = do
  !x0 <- peekByte @Word32 p
  !x1 <- peekByte @Word32 (p `plusPtr` 1)
  !x2 <- peekByte @Word32 (p `plusPtr` 2)
  !x3 <- peekByte @Word32 (p `plusPtr` 3)
  return $ x3 `unsafeShiftL` 24
    .|. x2 `unsafeShiftL` 16
    .|. x1 `unsafeShiftL` 8
    .|. x0

peek32BE p = do
  !x0 <- peekByte @Word32 p
  !x1 <- peekByte @Word32 (p `plusPtr` 1)
  !x2 <- peekByte @Word32 (p `plusPtr` 2)
  !x3 <- peekByte @Word32 (p `plusPtr` 3)
  return $ x0 `unsafeShiftL` 24
    .|. x1 `unsafeShiftL` 16
    .|. x2 `unsafeShiftL` 8
    .|. x3

peek64LE p = do
  !x0 <- peekByte @Word64 p
  !x1 <- peekByte @Word64 (p `plusPtr` 1)
  !x2 <- peekByte @Word64 (p `plusPtr` 2)
  !x3 <- peekByte @Word64 (p `plusPtr` 3)
  !x4 <- peekByte @Word64 (p `plusPtr` 4)
  !x5 <- peekByte @Word64 (p `plusPtr` 5)
  !x6 <- peekByte @Word64 (p `plusPtr` 6)
  !x7 <- peekByte @Word64 (p `plusPtr` 7)
  return $ x7 `unsafeShiftL` 56
    .|. x6 `unsafeShiftL` 48
    .|. x5 `unsafeShiftL` 40
    .|. x4 `unsafeShiftL` 32
    .|. x3 `unsafeShiftL` 24
    .|. x2 `unsafeShiftL` 16
    .|. x1 `unsafeShiftL` 8
    .|. x0

peek64BE p = do
  !x0 <- peekByte @Word64 p
  !x1 <- peekByte @Word64 (p `plusPtr` 1)
  !x2 <- peekByte @Word64 (p `plusPtr` 2)
  !x3 <- peekByte @Word64 (p `plusPtr` 3)
  !x4 <- peekByte @Word64 (p `plusPtr` 4)
  !x5 <- peekByte @Word64 (p `plusPtr` 5)
  !x6 <- peekByte @Word64 (p `plusPtr` 6)
  !x7 <- peekByte @Word64 (p `plusPtr` 7)
  return $ x0 `unsafeShiftL` 56
    .|. x1 `unsafeShiftL` 48
    .|. x2 `unsafeShiftL` 40
    .|. x3 `unsafeShiftL` 32
    .|. x4 `unsafeShiftL` 24
    .|. x5 `unsafeShiftL` 16
    .|. x6 `unsafeShiftL` 8
    .|. x7

#else
fromLE16 :: Word16 -> Word16
fromLE32 :: Word32 -> Word32
fromLE64 :: Word64 -> Word64
{-# INLINE fromLE16 #-}
{-# INLINE fromLE32 #-}
{-# INLINE fromLE64 #-}

fromBE16 :: Word16 -> Word16
fromBE32 :: Word32 -> Word32
fromBE64 :: Word64 -> Word64
{-# INLINE fromBE16 #-}
{-# INLINE fromBE32 #-}
{-# INLINE fromBE64 #-}

toLE16 :: Word16 -> Word16
toLE32 :: Word32 -> Word32
toLE64 :: Word64 -> Word64
{-# INLINE toLE16 #-}
{-# INLINE toLE32 #-}
{-# INLINE toLE64 #-}

toBE16 :: Word16 -> Word16
toBE32 :: Word32 -> Word32
toBE64 :: Word64 -> Word64
{-# INLINE toBE16 #-}
{-# INLINE toBE32 #-}
{-# INLINE toBE64 #-}

#ifdef WORDS_BIGENDIAN
fromBE16 = id
fromBE32 = id
fromBE64 = id
toBE16 = id
toBE32 = id
toBE64 = id
fromLE16 = byteSwap16
fromLE32 = byteSwap32
fromLE64 = byteSwap64
toLE16 = byteSwap16
toLE32 = byteSwap32
toLE64 = byteSwap64
#else
fromLE16 :: Word16 -> Word16
fromLE16 = Word16 -> Word16
forall a. a -> a
id
fromLE32 :: Word32 -> Word32
fromLE32 = Word32 -> Word32
forall a. a -> a
id
fromLE64 :: Word64 -> Word64
fromLE64 = Word64 -> Word64
forall a. a -> a
id
toLE16 :: Word16 -> Word16
toLE16 = Word16 -> Word16
forall a. a -> a
id
toLE32 :: Word32 -> Word32
toLE32 = Word32 -> Word32
forall a. a -> a
id
toLE64 :: Word64 -> Word64
toLE64 = Word64 -> Word64
forall a. a -> a
id
fromBE16 :: Word16 -> Word16
fromBE16 = Word16 -> Word16
byteSwap16
fromBE32 :: Word32 -> Word32
fromBE32 = Word32 -> Word32
byteSwap32
fromBE64 :: Word64 -> Word64
fromBE64 = Word64 -> Word64
byteSwap64
toBE16 :: Word16 -> Word16
toBE16 = Word16 -> Word16
byteSwap16
toBE32 :: Word32 -> Word32
toBE32 = Word32 -> Word32
byteSwap32
toBE64 :: Word64 -> Word64
toBE64 = Word64 -> Word64
byteSwap64
#endif

poke16LE :: Ptr Word8 -> Word16 -> IO ()
poke16LE Ptr Word8
p = Ptr Word16 -> Word16 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word16 Ptr Word8
p) (Word16 -> IO ()) -> (Word16 -> Word16) -> Word16 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word16
toLE16
poke32LE :: Ptr Word8 -> Word32 -> IO ()
poke32LE Ptr Word8
p = Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word32 Ptr Word8
p) (Word32 -> IO ()) -> (Word32 -> Word32) -> Word32 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word32
toLE32
poke64LE :: Ptr Word8 -> Word64 -> IO ()
poke64LE Ptr Word8
p = Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word64 Ptr Word8
p) (Word64 -> IO ()) -> (Word64 -> Word64) -> Word64 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Word64
toLE64

poke16BE :: Ptr Word8 -> Word16 -> IO ()
poke16BE Ptr Word8
p = Ptr Word16 -> Word16 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word16 Ptr Word8
p) (Word16 -> IO ()) -> (Word16 -> Word16) -> Word16 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word16
toBE16
poke32BE :: Ptr Word8 -> Word32 -> IO ()
poke32BE Ptr Word8
p = Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word32 Ptr Word8
p) (Word32 -> IO ()) -> (Word32 -> Word32) -> Word32 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word32
toBE32
poke64BE :: Ptr Word8 -> Word64 -> IO ()
poke64BE Ptr Word8
p = Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr @_ @Word64 Ptr Word8
p) (Word64 -> IO ()) -> (Word64 -> Word64) -> Word64 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Word64
toBE64

peek16LE :: Ptr Word8 -> IO Word16
peek16LE Ptr Word8
p = Word16 -> Word16
fromLE16 (Word16 -> Word16) -> IO Word16 -> IO Word16
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word16 -> IO Word16
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word16 Ptr Word8
p)
peek32LE :: Ptr Word8 -> IO Word32
peek32LE Ptr Word8
p = Word32 -> Word32
fromLE32 (Word32 -> Word32) -> IO Word32 -> IO Word32
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word32 Ptr Word8
p)
peek64LE :: Ptr Word8 -> IO Word64
peek64LE Ptr Word8
p = Word64 -> Word64
fromLE64 (Word64 -> Word64) -> IO Word64 -> IO Word64
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word64 Ptr Word8
p)

peek16BE :: Ptr Word8 -> IO Word16
peek16BE Ptr Word8
p = Word16 -> Word16
fromBE16 (Word16 -> Word16) -> IO Word16 -> IO Word16
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word16 -> IO Word16
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word16 Ptr Word8
p)
peek32BE :: Ptr Word8 -> IO Word32
peek32BE Ptr Word8
p = Word32 -> Word32
fromBE32 (Word32 -> Word32) -> IO Word32 -> IO Word32
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word32 Ptr Word8
p)
peek64BE :: Ptr Word8 -> IO Word64
peek64BE Ptr Word8
p = Word64 -> Word64
fromBE64 (Word64 -> Word64) -> IO Word64 -> IO Word64
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr @_ @Word64 Ptr Word8
p)
#endif

newtype BigEndian a = BigEndian {forall a. BigEndian a -> a
unBE :: a}
  deriving (Int -> BigEndian a -> ShowS
[BigEndian a] -> ShowS
BigEndian a -> String
(Int -> BigEndian a -> ShowS)
-> (BigEndian a -> String)
-> ([BigEndian a] -> ShowS)
-> Show (BigEndian a)
forall a. Show a => Int -> BigEndian a -> ShowS
forall a. Show a => [BigEndian a] -> ShowS
forall a. Show a => BigEndian a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> BigEndian a -> ShowS
showsPrec :: Int -> BigEndian a -> ShowS
$cshow :: forall a. Show a => BigEndian a -> String
show :: BigEndian a -> String
$cshowList :: forall a. Show a => [BigEndian a] -> ShowS
showList :: [BigEndian a] -> ShowS
Show, BigEndian a -> BigEndian a -> Bool
(BigEndian a -> BigEndian a -> Bool)
-> (BigEndian a -> BigEndian a -> Bool) -> Eq (BigEndian a)
forall a. Eq a => BigEndian a -> BigEndian a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => BigEndian a -> BigEndian a -> Bool
== :: BigEndian a -> BigEndian a -> Bool
$c/= :: forall a. Eq a => BigEndian a -> BigEndian a -> Bool
/= :: BigEndian a -> BigEndian a -> Bool
Eq, Eq (BigEndian a)
Eq (BigEndian a) =>
(BigEndian a -> BigEndian a -> Ordering)
-> (BigEndian a -> BigEndian a -> Bool)
-> (BigEndian a -> BigEndian a -> Bool)
-> (BigEndian a -> BigEndian a -> Bool)
-> (BigEndian a -> BigEndian a -> Bool)
-> (BigEndian a -> BigEndian a -> BigEndian a)
-> (BigEndian a -> BigEndian a -> BigEndian a)
-> Ord (BigEndian a)
BigEndian a -> BigEndian a -> Bool
BigEndian a -> BigEndian a -> Ordering
BigEndian a -> BigEndian a -> BigEndian a
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
forall a. Ord a => Eq (BigEndian a)
forall a. Ord a => BigEndian a -> BigEndian a -> Bool
forall a. Ord a => BigEndian a -> BigEndian a -> Ordering
forall a. Ord a => BigEndian a -> BigEndian a -> BigEndian a
$ccompare :: forall a. Ord a => BigEndian a -> BigEndian a -> Ordering
compare :: BigEndian a -> BigEndian a -> Ordering
$c< :: forall a. Ord a => BigEndian a -> BigEndian a -> Bool
< :: BigEndian a -> BigEndian a -> Bool
$c<= :: forall a. Ord a => BigEndian a -> BigEndian a -> Bool
<= :: BigEndian a -> BigEndian a -> Bool
$c> :: forall a. Ord a => BigEndian a -> BigEndian a -> Bool
> :: BigEndian a -> BigEndian a -> Bool
$c>= :: forall a. Ord a => BigEndian a -> BigEndian a -> Bool
>= :: BigEndian a -> BigEndian a -> Bool
$cmax :: forall a. Ord a => BigEndian a -> BigEndian a -> BigEndian a
max :: BigEndian a -> BigEndian a -> BigEndian a
$cmin :: forall a. Ord a => BigEndian a -> BigEndian a -> BigEndian a
min :: BigEndian a -> BigEndian a -> BigEndian a
Ord, (forall a b. (a -> b) -> BigEndian a -> BigEndian b)
-> (forall a b. a -> BigEndian b -> BigEndian a)
-> Functor BigEndian
forall a b. a -> BigEndian b -> BigEndian a
forall a b. (a -> b) -> BigEndian a -> BigEndian b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> BigEndian a -> BigEndian b
fmap :: forall a b. (a -> b) -> BigEndian a -> BigEndian b
$c<$ :: forall a b. a -> BigEndian b -> BigEndian a
<$ :: forall a b. a -> BigEndian b -> BigEndian a
Functor, (forall m. Monoid m => BigEndian m -> m)
-> (forall m a. Monoid m => (a -> m) -> BigEndian a -> m)
-> (forall m a. Monoid m => (a -> m) -> BigEndian a -> m)
-> (forall a b. (a -> b -> b) -> b -> BigEndian a -> b)
-> (forall a b. (a -> b -> b) -> b -> BigEndian a -> b)
-> (forall b a. (b -> a -> b) -> b -> BigEndian a -> b)
-> (forall b a. (b -> a -> b) -> b -> BigEndian a -> b)
-> (forall a. (a -> a -> a) -> BigEndian a -> a)
-> (forall a. (a -> a -> a) -> BigEndian a -> a)
-> (forall a. BigEndian a -> [a])
-> (forall a. BigEndian a -> Bool)
-> (forall a. BigEndian a -> Int)
-> (forall a. Eq a => a -> BigEndian a -> Bool)
-> (forall a. Ord a => BigEndian a -> a)
-> (forall a. Ord a => BigEndian a -> a)
-> (forall a. Num a => BigEndian a -> a)
-> (forall a. Num a => BigEndian a -> a)
-> Foldable BigEndian
forall a. Eq a => a -> BigEndian a -> Bool
forall a. Num a => BigEndian a -> a
forall a. Ord a => BigEndian a -> a
forall m. Monoid m => BigEndian m -> m
forall a. BigEndian a -> Bool
forall a. BigEndian a -> Int
forall a. BigEndian a -> [a]
forall a. (a -> a -> a) -> BigEndian a -> a
forall m a. Monoid m => (a -> m) -> BigEndian a -> m
forall b a. (b -> a -> b) -> b -> BigEndian a -> b
forall a b. (a -> b -> b) -> b -> BigEndian a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => BigEndian m -> m
fold :: forall m. Monoid m => BigEndian m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> BigEndian a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> BigEndian a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> BigEndian a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> BigEndian a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> BigEndian a -> b
foldr :: forall a b. (a -> b -> b) -> b -> BigEndian a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> BigEndian a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> BigEndian a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> BigEndian a -> b
foldl :: forall b a. (b -> a -> b) -> b -> BigEndian a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> BigEndian a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> BigEndian a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> BigEndian a -> a
foldr1 :: forall a. (a -> a -> a) -> BigEndian a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> BigEndian a -> a
foldl1 :: forall a. (a -> a -> a) -> BigEndian a -> a
$ctoList :: forall a. BigEndian a -> [a]
toList :: forall a. BigEndian a -> [a]
$cnull :: forall a. BigEndian a -> Bool
null :: forall a. BigEndian a -> Bool
$clength :: forall a. BigEndian a -> Int
length :: forall a. BigEndian a -> Int
$celem :: forall a. Eq a => a -> BigEndian a -> Bool
elem :: forall a. Eq a => a -> BigEndian a -> Bool
$cmaximum :: forall a. Ord a => BigEndian a -> a
maximum :: forall a. Ord a => BigEndian a -> a
$cminimum :: forall a. Ord a => BigEndian a -> a
minimum :: forall a. Ord a => BigEndian a -> a
$csum :: forall a. Num a => BigEndian a -> a
sum :: forall a. Num a => BigEndian a -> a
$cproduct :: forall a. Num a => BigEndian a -> a
product :: forall a. Num a => BigEndian a -> a
Foldable, Functor BigEndian
Foldable BigEndian
(Functor BigEndian, Foldable BigEndian) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> BigEndian a -> f (BigEndian b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    BigEndian (f a) -> f (BigEndian a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BigEndian a -> m (BigEndian b))
-> (forall (m :: * -> *) a.
    Monad m =>
    BigEndian (m a) -> m (BigEndian a))
-> Traversable BigEndian
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
BigEndian (m a) -> m (BigEndian a)
forall (f :: * -> *) a.
Applicative f =>
BigEndian (f a) -> f (BigEndian a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BigEndian a -> m (BigEndian b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BigEndian a -> f (BigEndian b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BigEndian a -> f (BigEndian b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BigEndian a -> f (BigEndian b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
BigEndian (f a) -> f (BigEndian a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
BigEndian (f a) -> f (BigEndian a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BigEndian a -> m (BigEndian b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BigEndian a -> m (BigEndian b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
BigEndian (m a) -> m (BigEndian a)
sequence :: forall (m :: * -> *) a.
Monad m =>
BigEndian (m a) -> m (BigEndian a)
Traversable, (forall x. BigEndian a -> Rep (BigEndian a) x)
-> (forall x. Rep (BigEndian a) x -> BigEndian a)
-> Generic (BigEndian a)
forall x. Rep (BigEndian a) x -> BigEndian a
forall x. BigEndian a -> Rep (BigEndian a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (BigEndian a) x -> BigEndian a
forall a x. BigEndian a -> Rep (BigEndian a) x
$cfrom :: forall a x. BigEndian a -> Rep (BigEndian a) x
from :: forall x. BigEndian a -> Rep (BigEndian a) x
$cto :: forall a x. Rep (BigEndian a) x -> BigEndian a
to :: forall x. Rep (BigEndian a) x -> BigEndian a
Generic)

newtype LittleEndian a = LittleEndian {forall a. LittleEndian a -> a
unLE :: a}
  deriving (Int -> LittleEndian a -> ShowS
[LittleEndian a] -> ShowS
LittleEndian a -> String
(Int -> LittleEndian a -> ShowS)
-> (LittleEndian a -> String)
-> ([LittleEndian a] -> ShowS)
-> Show (LittleEndian a)
forall a. Show a => Int -> LittleEndian a -> ShowS
forall a. Show a => [LittleEndian a] -> ShowS
forall a. Show a => LittleEndian a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> LittleEndian a -> ShowS
showsPrec :: Int -> LittleEndian a -> ShowS
$cshow :: forall a. Show a => LittleEndian a -> String
show :: LittleEndian a -> String
$cshowList :: forall a. Show a => [LittleEndian a] -> ShowS
showList :: [LittleEndian a] -> ShowS
Show, LittleEndian a -> LittleEndian a -> Bool
(LittleEndian a -> LittleEndian a -> Bool)
-> (LittleEndian a -> LittleEndian a -> Bool)
-> Eq (LittleEndian a)
forall a. Eq a => LittleEndian a -> LittleEndian a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => LittleEndian a -> LittleEndian a -> Bool
== :: LittleEndian a -> LittleEndian a -> Bool
$c/= :: forall a. Eq a => LittleEndian a -> LittleEndian a -> Bool
/= :: LittleEndian a -> LittleEndian a -> Bool
Eq, Eq (LittleEndian a)
Eq (LittleEndian a) =>
(LittleEndian a -> LittleEndian a -> Ordering)
-> (LittleEndian a -> LittleEndian a -> Bool)
-> (LittleEndian a -> LittleEndian a -> Bool)
-> (LittleEndian a -> LittleEndian a -> Bool)
-> (LittleEndian a -> LittleEndian a -> Bool)
-> (LittleEndian a -> LittleEndian a -> LittleEndian a)
-> (LittleEndian a -> LittleEndian a -> LittleEndian a)
-> Ord (LittleEndian a)
LittleEndian a -> LittleEndian a -> Bool
LittleEndian a -> LittleEndian a -> Ordering
LittleEndian a -> LittleEndian a -> LittleEndian a
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
forall a. Ord a => Eq (LittleEndian a)
forall a. Ord a => LittleEndian a -> LittleEndian a -> Bool
forall a. Ord a => LittleEndian a -> LittleEndian a -> Ordering
forall a.
Ord a =>
LittleEndian a -> LittleEndian a -> LittleEndian a
$ccompare :: forall a. Ord a => LittleEndian a -> LittleEndian a -> Ordering
compare :: LittleEndian a -> LittleEndian a -> Ordering
$c< :: forall a. Ord a => LittleEndian a -> LittleEndian a -> Bool
< :: LittleEndian a -> LittleEndian a -> Bool
$c<= :: forall a. Ord a => LittleEndian a -> LittleEndian a -> Bool
<= :: LittleEndian a -> LittleEndian a -> Bool
$c> :: forall a. Ord a => LittleEndian a -> LittleEndian a -> Bool
> :: LittleEndian a -> LittleEndian a -> Bool
$c>= :: forall a. Ord a => LittleEndian a -> LittleEndian a -> Bool
>= :: LittleEndian a -> LittleEndian a -> Bool
$cmax :: forall a.
Ord a =>
LittleEndian a -> LittleEndian a -> LittleEndian a
max :: LittleEndian a -> LittleEndian a -> LittleEndian a
$cmin :: forall a.
Ord a =>
LittleEndian a -> LittleEndian a -> LittleEndian a
min :: LittleEndian a -> LittleEndian a -> LittleEndian a
Ord, (forall a b. (a -> b) -> LittleEndian a -> LittleEndian b)
-> (forall a b. a -> LittleEndian b -> LittleEndian a)
-> Functor LittleEndian
forall a b. a -> LittleEndian b -> LittleEndian a
forall a b. (a -> b) -> LittleEndian a -> LittleEndian b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> LittleEndian a -> LittleEndian b
fmap :: forall a b. (a -> b) -> LittleEndian a -> LittleEndian b
$c<$ :: forall a b. a -> LittleEndian b -> LittleEndian a
<$ :: forall a b. a -> LittleEndian b -> LittleEndian a
Functor, (forall m. Monoid m => LittleEndian m -> m)
-> (forall m a. Monoid m => (a -> m) -> LittleEndian a -> m)
-> (forall m a. Monoid m => (a -> m) -> LittleEndian a -> m)
-> (forall a b. (a -> b -> b) -> b -> LittleEndian a -> b)
-> (forall a b. (a -> b -> b) -> b -> LittleEndian a -> b)
-> (forall b a. (b -> a -> b) -> b -> LittleEndian a -> b)
-> (forall b a. (b -> a -> b) -> b -> LittleEndian a -> b)
-> (forall a. (a -> a -> a) -> LittleEndian a -> a)
-> (forall a. (a -> a -> a) -> LittleEndian a -> a)
-> (forall a. LittleEndian a -> [a])
-> (forall a. LittleEndian a -> Bool)
-> (forall a. LittleEndian a -> Int)
-> (forall a. Eq a => a -> LittleEndian a -> Bool)
-> (forall a. Ord a => LittleEndian a -> a)
-> (forall a. Ord a => LittleEndian a -> a)
-> (forall a. Num a => LittleEndian a -> a)
-> (forall a. Num a => LittleEndian a -> a)
-> Foldable LittleEndian
forall a. Eq a => a -> LittleEndian a -> Bool
forall a. Num a => LittleEndian a -> a
forall a. Ord a => LittleEndian a -> a
forall m. Monoid m => LittleEndian m -> m
forall a. LittleEndian a -> Bool
forall a. LittleEndian a -> Int
forall a. LittleEndian a -> [a]
forall a. (a -> a -> a) -> LittleEndian a -> a
forall m a. Monoid m => (a -> m) -> LittleEndian a -> m
forall b a. (b -> a -> b) -> b -> LittleEndian a -> b
forall a b. (a -> b -> b) -> b -> LittleEndian a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => LittleEndian m -> m
fold :: forall m. Monoid m => LittleEndian m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> LittleEndian a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LittleEndian a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> LittleEndian a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> LittleEndian a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> LittleEndian a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LittleEndian a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> LittleEndian a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LittleEndian a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> LittleEndian a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LittleEndian a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> LittleEndian a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> LittleEndian a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> LittleEndian a -> a
foldr1 :: forall a. (a -> a -> a) -> LittleEndian a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LittleEndian a -> a
foldl1 :: forall a. (a -> a -> a) -> LittleEndian a -> a
$ctoList :: forall a. LittleEndian a -> [a]
toList :: forall a. LittleEndian a -> [a]
$cnull :: forall a. LittleEndian a -> Bool
null :: forall a. LittleEndian a -> Bool
$clength :: forall a. LittleEndian a -> Int
length :: forall a. LittleEndian a -> Int
$celem :: forall a. Eq a => a -> LittleEndian a -> Bool
elem :: forall a. Eq a => a -> LittleEndian a -> Bool
$cmaximum :: forall a. Ord a => LittleEndian a -> a
maximum :: forall a. Ord a => LittleEndian a -> a
$cminimum :: forall a. Ord a => LittleEndian a -> a
minimum :: forall a. Ord a => LittleEndian a -> a
$csum :: forall a. Num a => LittleEndian a -> a
sum :: forall a. Num a => LittleEndian a -> a
$cproduct :: forall a. Num a => LittleEndian a -> a
product :: forall a. Num a => LittleEndian a -> a
Foldable, Functor LittleEndian
Foldable LittleEndian
(Functor LittleEndian, Foldable LittleEndian) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> LittleEndian a -> f (LittleEndian b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    LittleEndian (f a) -> f (LittleEndian a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> LittleEndian a -> m (LittleEndian b))
-> (forall (m :: * -> *) a.
    Monad m =>
    LittleEndian (m a) -> m (LittleEndian a))
-> Traversable LittleEndian
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
LittleEndian (m a) -> m (LittleEndian a)
forall (f :: * -> *) a.
Applicative f =>
LittleEndian (f a) -> f (LittleEndian a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LittleEndian a -> m (LittleEndian b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LittleEndian a -> f (LittleEndian b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LittleEndian a -> f (LittleEndian b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LittleEndian a -> f (LittleEndian b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
LittleEndian (f a) -> f (LittleEndian a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LittleEndian (f a) -> f (LittleEndian a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LittleEndian a -> m (LittleEndian b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LittleEndian a -> m (LittleEndian b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
LittleEndian (m a) -> m (LittleEndian a)
sequence :: forall (m :: * -> *) a.
Monad m =>
LittleEndian (m a) -> m (LittleEndian a)
Traversable, (forall x. LittleEndian a -> Rep (LittleEndian a) x)
-> (forall x. Rep (LittleEndian a) x -> LittleEndian a)
-> Generic (LittleEndian a)
forall x. Rep (LittleEndian a) x -> LittleEndian a
forall x. LittleEndian a -> Rep (LittleEndian a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (LittleEndian a) x -> LittleEndian a
forall a x. LittleEndian a -> Rep (LittleEndian a) x
$cfrom :: forall a x. LittleEndian a -> Rep (LittleEndian a) x
from :: forall x. LittleEndian a -> Rep (LittleEndian a) x
$cto :: forall a x. Rep (LittleEndian a) x -> LittleEndian a
to :: forall x. Rep (LittleEndian a) x -> LittleEndian a
Generic)

class Persist t where
  -- | Encode a value in the Put monad.
  put :: t -> Put ()

  -- | Decode a value in the Get monad
  get :: Get t

  -- | Encode a value without checking for sufficient size.
  unsafePut :: t -> Put ()
  unsafePut = t -> Put ()
forall t. Persist t => t -> Put ()
put

  -- | Decode a value without checking for sufficient size.
  unsafeGet :: Get t
  unsafeGet = Get t
forall t. Persist t => Get t
get

  default put :: (Generic t, GPersistPut (Rep t)) => t -> Put ()
  put = Rep t Any -> Put ()
forall a. Rep t a -> Put ()
forall (f :: * -> *) a. GPersistPut f => f a -> Put ()
gput (Rep t Any -> Put ()) -> (t -> Rep t Any) -> t -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> Rep t Any
forall x. t -> Rep t x
forall a x. Generic a => a -> Rep a x
from

  default get :: (Generic t, GPersistGet (Rep t)) => Get t
  get = Rep t Any -> t
forall a x. Generic a => Rep a x -> a
forall x. Rep t x -> t
to (Rep t Any -> t) -> Get (Rep t Any) -> Get t
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get (Rep t Any)
forall a. Get (Rep t a)
forall (f :: * -> *) a. GPersistGet f => Get (f a)
gget

-- | Encode a value using binary serialization to a strict ByteString.
encode :: (Persist a) => a -> ByteString
encode :: forall a. Persist a => a -> ByteString
encode = Put () -> ByteString
forall a. Put a -> ByteString
runPut (Put () -> ByteString) -> (a -> Put ()) -> a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Put ()
forall t. Persist t => t -> Put ()
put

-- | Encode a value using binary serialization to a lazy ByteString.
encodeLazy :: (Persist a) => a -> L.ByteString
encodeLazy :: forall a. Persist a => a -> ByteString
encodeLazy = Put () -> ByteString
forall a. Put a -> ByteString
runPutLazy (Put () -> ByteString) -> (a -> Put ()) -> a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Put ()
forall t. Persist t => t -> Put ()
put


{- | Decode a value from a strict ByteString, reconstructing the original
structure.
-}
decode :: (Persist a) => ByteString -> Either String a
decode :: forall a. Persist a => ByteString -> Either String a
decode = Get a -> ByteString -> Either String a
forall a. Get a -> ByteString -> Either String a
runGet Get a
forall t. Persist t => Get t
get

putLE :: (Persist (LittleEndian a)) => a -> Put ()
putLE :: forall a. Persist (HostEndian a) => a -> Put ()
putLE = LittleEndian a -> Put ()
forall t. Persist t => t -> Put ()
put (LittleEndian a -> Put ()) -> (a -> LittleEndian a) -> a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> LittleEndian a
forall a. a -> LittleEndian a
LittleEndian
{-# INLINE putLE #-}

putBE :: (Persist (BigEndian a)) => a -> Put ()
putBE :: forall a. Persist (BigEndian a) => a -> Put ()
putBE = BigEndian a -> Put ()
forall t. Persist t => t -> Put ()
put (BigEndian a -> Put ()) -> (a -> BigEndian a) -> a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> BigEndian a
forall a. a -> BigEndian a
BigEndian
{-# INLINE putBE #-}

getLE :: forall a. (Persist (LittleEndian a)) => Get a
getLE :: forall a. Persist (HostEndian a) => Get a
getLE = (.unLE) (LittleEndian a -> a) -> Get (LittleEndian a) -> Get a
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall t. Persist t => Get t
get @(LittleEndian a)
{-# INLINE getLE #-}

getBE :: forall a. (Persist (BigEndian a)) => Get a
getBE :: forall a. Persist (BigEndian a) => Get a
getBE = (.unBE) (BigEndian a -> a) -> Get (BigEndian a) -> Get a
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall t. Persist t => Get t
get @(BigEndian a)
{-# INLINE getBE #-}

unsafePutByte :: (Integral a) => a -> Put ()
unsafePutByte :: forall a. Integral a => a -> Put ()
unsafePutByte a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word8 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr Word8
p (Word8 -> IO ()) -> Word8 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePutByte #-}

unsafePut16LE :: (Integral a) => a -> Put ()
unsafePut16LE :: forall a. Integral a => a -> Put ()
unsafePut16LE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word16 -> IO ()
poke16LE Ptr Word8
p (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut16LE #-}

unsafePut32LE :: (Integral a) => a -> Put ()
unsafePut32LE :: forall a. Integral a => a -> Put ()
unsafePut32LE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word32 -> IO ()
poke32LE Ptr Word8
p (Word32 -> IO ()) -> Word32 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut32LE #-}

unsafePut64LE :: (Integral a) => a -> Put ()
unsafePut64LE :: forall a. Integral a => a -> Put ()
unsafePut64LE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word64 -> IO ()
poke64LE Ptr Word8
p (Word64 -> IO ()) -> Word64 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut64LE #-}

unsafePut16BE :: (Integral a) => a -> Put ()
unsafePut16BE :: forall a. Integral a => a -> Put ()
unsafePut16BE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word16 -> IO ()
poke16BE Ptr Word8
p (Word16 -> IO ()) -> Word16 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut16BE #-}

unsafePut32BE :: (Integral a) => a -> Put ()
unsafePut32BE :: forall a. Integral a => a -> Put ()
unsafePut32BE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word32 -> IO ()
poke32BE Ptr Word8
p (Word32 -> IO ()) -> Word32 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut32BE #-}

unsafePut64BE :: (Integral a) => a -> Put ()
unsafePut64BE :: forall a. Integral a => a -> Put ()
unsafePut64BE a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
  Ptr Word8 -> Word64 -> IO ()
poke64BE Ptr Word8
p (Word64 -> IO ()) -> Word64 -> IO ()
forall a b. (a -> b) -> a -> b
$ a -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE unsafePut64BE #-}

unsafeGetByte :: (Num a) => Get a
unsafeGetByte :: forall a. Num a => Get a
unsafeGetByte = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word8
x <- Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x
{-# INLINE unsafeGetByte #-}

unsafeGet16LE :: (Num a) => Get a
unsafeGet16LE :: forall a. Num a => Get a
unsafeGet16LE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word16
x <- Ptr Word8 -> IO Word16
peek16LE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word16 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
x
{-# INLINE unsafeGet16LE #-}

unsafeGet32LE :: (Num a) => Get a
unsafeGet32LE :: forall a. Num a => Get a
unsafeGet32LE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word32
x <- Ptr Word8 -> IO Word32
peek32LE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word32 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x
{-# INLINE unsafeGet32LE #-}

unsafeGet64LE :: (Num a) => Get a
unsafeGet64LE :: forall a. Num a => Get a
unsafeGet64LE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word64
x <- Ptr Word8 -> IO Word64
peek64LE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word64 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x
{-# INLINE unsafeGet64LE #-}

unsafeGet16BE :: (Num a) => Get a
unsafeGet16BE :: forall a. Num a => Get a
unsafeGet16BE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word16
x <- Ptr Word8 -> IO Word16
peek16BE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
2 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word16 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
x
{-# INLINE unsafeGet16BE #-}

unsafeGet32BE :: (Num a) => Get a
unsafeGet32BE :: forall a. Num a => Get a
unsafeGet32BE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word32
x <- Ptr Word8 -> IO Word32
peek32BE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word32 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x
{-# INLINE unsafeGet32BE #-}

unsafeGet64BE :: (Num a) => Get a
unsafeGet64BE :: forall a. Num a => Get a
unsafeGet64BE = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> do
  Word64
x <- Ptr Word8 -> IO Word64
peek64BE Ptr Word8
p
  (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a))
-> (Ptr Word8 :!: a) -> IO (Ptr Word8 :!: a)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 Ptr Word8 -> a -> Ptr Word8 :!: a
forall a b. a -> b -> a :!: b
:!: Word64 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x
{-# INLINE unsafeGet64BE #-}

reinterpretCast :: (Storable a, Storable b) => Ptr p -> a -> IO b
reinterpretCast :: forall a b p. (Storable a, Storable b) => Ptr p -> a -> IO b
reinterpretCast Ptr p
p a
x = do
  Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr p -> Ptr a
forall a b. Ptr a -> Ptr b
castPtr Ptr p
p) a
x
  Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek (Ptr p -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr p
p)
{-# INLINE reinterpretCast #-}

reinterpretCastPut :: (Storable a, Storable b) => a -> Put b
reinterpretCastPut :: forall a b. (Storable a, Storable b) => a -> Put b
reinterpretCastPut a
x = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Put b
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Put b)
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Put b
forall a b. (a -> b) -> a -> b
$ \PutEnv
e Ptr Word8
p -> (Ptr Word8
p Ptr Word8 -> b -> Ptr Word8 :!: b
forall a b. a -> b -> a :!: b
:!:) (b -> Ptr Word8 :!: b) -> IO b -> IO (Ptr Word8 :!: b)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word8 -> a -> IO b
forall a b p. (Storable a, Storable b) => Ptr p -> a -> IO b
reinterpretCast PutEnv
e.tmp a
x
{-# INLINE reinterpretCastPut #-}

reinterpretCastGet :: (Storable a, Storable b) => a -> Get b
reinterpretCastGet :: forall a b. (Storable a, Storable b) => a -> Get b
reinterpretCastGet a
x = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Get b
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Get b)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: b)) -> Get b
forall a b. (a -> b) -> a -> b
$ \GetEnv
e Ptr Word8
p -> (Ptr Word8
p Ptr Word8 -> b -> Ptr Word8 :!: b
forall a b. a -> b -> a :!: b
:!:) (b -> Ptr Word8 :!: b) -> IO b -> IO (Ptr Word8 :!: b)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Ptr Word8 -> a -> IO b
forall a b p. (Storable a, Storable b) => Ptr p -> a -> IO b
reinterpretCast GetEnv
e.tmp a
x
{-# INLINE reinterpretCastGet #-}

-- The () type need never be written to disk: values of singleton type
-- can be reconstructed from the type alone
instance Persist () where
  put :: () -> Put ()
put () = () -> Put ()
forall a. a -> Put a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  {-# INLINE put #-}
  get :: Get ()
get = () -> Get ()
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  {-# INLINE get #-}

class HasEndianness a where
  unsafeGetLE :: Get a
  unsafePutLE :: a -> Put ()
  unsafeGetBE :: Get a
  unsafePutBE :: a -> Put ()
  endiannessSize :: Int

instance HasEndianness Word8 where
  unsafeGetLE :: Get Word8
unsafeGetLE = Get Word8
forall a. Num a => Get a
unsafeGetByte
  unsafeGetBE :: Get Word8
unsafeGetBE = Get Word8
forall a. Num a => Get a
unsafeGetByte
  unsafePutLE :: Word8 -> Put ()
unsafePutLE = Word8 -> Put ()
forall a. Integral a => a -> Put ()
unsafePutByte
  unsafePutBE :: Word8 -> Put ()
unsafePutBE = Word8 -> Put ()
forall a. Integral a => a -> Put ()
unsafePutByte
  endiannessSize :: Int
endiannessSize = Int
1

instance HasEndianness Word16 where
  unsafeGetLE :: Get Word16
unsafeGetLE = Get Word16
forall a. Num a => Get a
unsafeGet16LE
  {-# INLINE unsafeGetLE #-}
  unsafeGetBE :: Get Word16
unsafeGetBE = Get Word16
forall a. Num a => Get a
unsafeGet16BE
  {-# INLINE unsafeGetBE #-}
  unsafePutLE :: Word16 -> Put ()
unsafePutLE = Word16 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut16LE
  {-# INLINE unsafePutLE #-}
  unsafePutBE :: Word16 -> Put ()
unsafePutBE = Word16 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut16BE
  {-# INLINE unsafePutBE #-}
  endiannessSize :: Int
endiannessSize = Int
2
  {-# INLINE endiannessSize #-}

instance HasEndianness Word32 where
  unsafeGetLE :: Get Word32
unsafeGetLE = Get Word32
forall a. Num a => Get a
unsafeGet32LE
  {-# INLINE unsafeGetLE #-}
  unsafeGetBE :: Get Word32
unsafeGetBE = Get Word32
forall a. Num a => Get a
unsafeGet32BE
  {-# INLINE unsafeGetBE #-}
  unsafePutLE :: Word32 -> Put ()
unsafePutLE = Word32 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut32LE
  {-# INLINE unsafePutLE #-}
  unsafePutBE :: Word32 -> Put ()
unsafePutBE = Word32 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut32BE
  {-# INLINE unsafePutBE #-}
  endiannessSize :: Int
endiannessSize = Int
4
  {-# INLINE endiannessSize #-}

instance HasEndianness Word64 where
  unsafeGetLE :: Get Word64
unsafeGetLE = Get Word64
forall a. Num a => Get a
unsafeGet64LE
  {-# INLINE unsafeGetLE #-}
  unsafeGetBE :: Get Word64
unsafeGetBE = Get Word64
forall a. Num a => Get a
unsafeGet64BE
  {-# INLINE unsafeGetBE #-}
  unsafePutLE :: Word64 -> Put ()
unsafePutLE = Word64 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut64LE
  {-# INLINE unsafePutLE #-}
  unsafePutBE :: Word64 -> Put ()
unsafePutBE = Word64 -> Put ()
forall a. Integral a => a -> Put ()
unsafePut64BE
  {-# INLINE unsafePutBE #-}
  endiannessSize :: Int
endiannessSize = Int
8
  {-# INLINE endiannessSize #-}

instance (HasEndianness a) => Persist (LittleEndian a) where
  put :: LittleEndian a -> Put ()
put LittleEndian a
x = do
    Int -> Put ()
grow (forall a. HasEndianness a => Int
endiannessSize @a)
    LittleEndian a -> Put ()
forall t. Persist t => t -> Put ()
unsafePut LittleEndian a
x
  {-# INLINE put #-}

  unsafePut :: LittleEndian a -> Put ()
unsafePut = a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutLE (a -> Put ()) -> (LittleEndian a -> a) -> LittleEndian a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (.unLE)
  {-# INLINE unsafePut #-}

  get :: Get (LittleEndian a)
get = do
    Int -> Get ()
ensure (forall a. HasEndianness a => Int
endiannessSize @a)
    Get (LittleEndian a)
forall t. Persist t => Get t
unsafeGet
  {-# INLINE get #-}

  unsafeGet :: Get (LittleEndian a)
unsafeGet = a -> LittleEndian a
forall a. a -> LittleEndian a
LittleEndian (a -> LittleEndian a) -> Get a -> Get (LittleEndian a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get a
forall a. HasEndianness a => Get a
unsafeGetLE
  {-# INLINE unsafeGet #-}

instance (HasEndianness a) => Persist (BigEndian a) where
  put :: BigEndian a -> Put ()
put BigEndian a
x = do
    Int -> Put ()
grow (forall a. HasEndianness a => Int
endiannessSize @a)
    BigEndian a -> Put ()
forall t. Persist t => t -> Put ()
unsafePut BigEndian a
x
  {-# INLINE put #-}

  unsafePut :: BigEndian a -> Put ()
unsafePut = a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutBE (a -> Put ()) -> (BigEndian a -> a) -> BigEndian a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (.unBE)
  {-# INLINE unsafePut #-}

  get :: Get (BigEndian a)
get = do
    Int -> Get ()
ensure (forall a. HasEndianness a => Int
endiannessSize @a)
    Get (BigEndian a)
forall t. Persist t => Get t
unsafeGet
  {-# INLINE get #-}

  unsafeGet :: Get (BigEndian a)
unsafeGet = a -> BigEndian a
forall a. a -> BigEndian a
BigEndian (a -> BigEndian a) -> Get a -> Get (BigEndian a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get a
forall a. HasEndianness a => Get a
unsafeGetBE
  {-# INLINE unsafeGet #-}

deriving via (LittleEndian Word8) instance Persist Word8
deriving via (LittleEndian Word16) instance Persist Word16
deriving via (LittleEndian Word32) instance Persist Word32
deriving via (LittleEndian Word64) instance Persist Word64

class SerializeAs a where
  type SerializeTarget a
  castPut :: a -> SerializeTarget a
  castGet :: SerializeTarget a -> a

instance SerializeAs Int8 where
  type SerializeTarget Int8 = Word8
  castPut :: Int8 -> SerializeTarget Int8
castPut = Int8 -> Word8
Int8 -> SerializeTarget Int8
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Int8 -> Int8
castGet = Word8 -> Int8
SerializeTarget Int8 -> Int8
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance SerializeAs Int16 where
  type SerializeTarget Int16 = Word16
  castPut :: Int16 -> SerializeTarget Int16
castPut = Int16 -> Word16
Int16 -> SerializeTarget Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Int16 -> Int16
castGet = Word16 -> Int16
SerializeTarget Int16 -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance SerializeAs Int32 where
  type SerializeTarget Int32 = Word32
  castPut :: Int32 -> SerializeTarget Int32
castPut = Int32 -> Word32
Int32 -> SerializeTarget Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Int32 -> Int32
castGet = Word32 -> Int32
SerializeTarget Int32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance SerializeAs Int64 where
  type SerializeTarget Int64 = Word64
  castPut :: Int64 -> SerializeTarget Int64
castPut = Int64 -> Word64
Int64 -> SerializeTarget Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Int64 -> Int64
castGet = Word64 -> Int64
SerializeTarget Int64 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral

newtype ViaSerializeAs a = MkViaSerializeAs a
  deriving (ViaSerializeAs a -> ViaSerializeAs a -> Bool
(ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> (ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> Eq (ViaSerializeAs a)
forall a. Eq a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
== :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
$c/= :: forall a. Eq a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
/= :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
Eq, Eq (ViaSerializeAs a)
Eq (ViaSerializeAs a) =>
(ViaSerializeAs a -> ViaSerializeAs a -> Ordering)
-> (ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> (ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> (ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> (ViaSerializeAs a -> ViaSerializeAs a -> Bool)
-> (ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a)
-> (ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a)
-> Ord (ViaSerializeAs a)
ViaSerializeAs a -> ViaSerializeAs a -> Bool
ViaSerializeAs a -> ViaSerializeAs a -> Ordering
ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
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
forall a. Ord a => Eq (ViaSerializeAs a)
forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Ordering
forall a.
Ord a =>
ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
$ccompare :: forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Ordering
compare :: ViaSerializeAs a -> ViaSerializeAs a -> Ordering
$c< :: forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
< :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
$c<= :: forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
<= :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
$c> :: forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
> :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
$c>= :: forall a. Ord a => ViaSerializeAs a -> ViaSerializeAs a -> Bool
>= :: ViaSerializeAs a -> ViaSerializeAs a -> Bool
$cmax :: forall a.
Ord a =>
ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
max :: ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
$cmin :: forall a.
Ord a =>
ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
min :: ViaSerializeAs a -> ViaSerializeAs a -> ViaSerializeAs a
Ord, Int -> ViaSerializeAs a -> ShowS
[ViaSerializeAs a] -> ShowS
ViaSerializeAs a -> String
(Int -> ViaSerializeAs a -> ShowS)
-> (ViaSerializeAs a -> String)
-> ([ViaSerializeAs a] -> ShowS)
-> Show (ViaSerializeAs a)
forall a. Show a => Int -> ViaSerializeAs a -> ShowS
forall a. Show a => [ViaSerializeAs a] -> ShowS
forall a. Show a => ViaSerializeAs a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ViaSerializeAs a -> ShowS
showsPrec :: Int -> ViaSerializeAs a -> ShowS
$cshow :: forall a. Show a => ViaSerializeAs a -> String
show :: ViaSerializeAs a -> String
$cshowList :: forall a. Show a => [ViaSerializeAs a] -> ShowS
showList :: [ViaSerializeAs a] -> ShowS
Show)

instance (SerializeAs a, HasEndianness (SerializeTarget a)) => HasEndianness (ViaSerializeAs a) where
  endiannessSize :: Int
endiannessSize = forall a. HasEndianness a => Int
endiannessSize @(SerializeTarget a)
  {-# INLINE endiannessSize #-}
  unsafeGetBE :: Get (ViaSerializeAs a)
unsafeGetBE = a -> ViaSerializeAs a
forall a. a -> ViaSerializeAs a
MkViaSerializeAs (a -> ViaSerializeAs a)
-> (SerializeTarget a -> a)
-> SerializeTarget a
-> ViaSerializeAs a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerializeTarget a -> a
forall a. SerializeAs a => SerializeTarget a -> a
castGet (SerializeTarget a -> ViaSerializeAs a)
-> Get (SerializeTarget a) -> Get (ViaSerializeAs a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get (SerializeTarget a)
forall a. HasEndianness a => Get a
unsafeGetBE
  {-# INLINE unsafeGetBE #-}
  unsafeGetLE :: Get (ViaSerializeAs a)
unsafeGetLE = a -> ViaSerializeAs a
forall a. a -> ViaSerializeAs a
MkViaSerializeAs (a -> ViaSerializeAs a)
-> (SerializeTarget a -> a)
-> SerializeTarget a
-> ViaSerializeAs a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerializeTarget a -> a
forall a. SerializeAs a => SerializeTarget a -> a
castGet (SerializeTarget a -> ViaSerializeAs a)
-> Get (SerializeTarget a) -> Get (ViaSerializeAs a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get (SerializeTarget a)
forall a. HasEndianness a => Get a
unsafeGetLE
  {-# INLINE unsafeGetLE #-}
  unsafePutBE :: ViaSerializeAs a -> Put ()
unsafePutBE (MkViaSerializeAs a
x) = SerializeTarget a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutBE (SerializeTarget a -> Put ())
-> (a -> SerializeTarget a) -> a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> SerializeTarget a
forall a. SerializeAs a => a -> SerializeTarget a
castPut (a -> Put ()) -> a -> Put ()
forall a b. (a -> b) -> a -> b
$! a
x
  {-# INLINE unsafePutBE #-}
  unsafePutLE :: ViaSerializeAs a -> Put ()
unsafePutLE (MkViaSerializeAs a
x) = SerializeTarget a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutLE (SerializeTarget a -> Put ())
-> (a -> SerializeTarget a) -> a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> SerializeTarget a
forall a. SerializeAs a => a -> SerializeTarget a
castPut (a -> Put ()) -> a -> Put ()
forall a b. (a -> b) -> a -> b
$! a
x
  {-# INLINE unsafePutLE #-}

deriving via (ViaSerializeAs Int8) instance HasEndianness Int8
deriving via (ViaSerializeAs Int16) instance HasEndianness Int16
deriving via (ViaSerializeAs Int32) instance HasEndianness Int32
deriving via (ViaSerializeAs Int64) instance HasEndianness Int64

deriving via (LittleEndian Int8) instance Persist Int8
deriving via (LittleEndian Int16) instance Persist Int16
deriving via (LittleEndian Int32) instance Persist Int32
deriving via (LittleEndian Int64) instance Persist Int64

instance SerializeAs Word where
  type SerializeTarget Word = Word64
  castPut :: Word -> SerializeTarget Word
castPut = Word -> Word64
Word -> SerializeTarget Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Word -> Word
castGet = Word64 -> Word
SerializeTarget Word -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance SerializeAs Int where
  type SerializeTarget Int = Int64
  castPut :: Int -> SerializeTarget Int
castPut = Int -> Int64
Int -> SerializeTarget Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  castGet :: SerializeTarget Int -> Int
castGet = Int64 -> Int
SerializeTarget Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance (SerializeAs a, Persist (SerializeTarget a)) => Persist (ViaSerializeAs a) where
  put :: ViaSerializeAs a -> Put ()
put (MkViaSerializeAs a
x) = SerializeTarget a -> Put ()
forall t. Persist t => t -> Put ()
put (a -> SerializeTarget a
forall a. SerializeAs a => a -> SerializeTarget a
castPut a
x)
  {-# INLINE put #-}
  unsafePut :: ViaSerializeAs a -> Put ()
unsafePut (MkViaSerializeAs a
x) = SerializeTarget a -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (a -> SerializeTarget a
forall a. SerializeAs a => a -> SerializeTarget a
castPut a
x)
  {-# INLINE unsafePut #-}
  get :: Get (ViaSerializeAs a)
get = a -> ViaSerializeAs a
forall a. a -> ViaSerializeAs a
MkViaSerializeAs (a -> ViaSerializeAs a)
-> (SerializeTarget a -> a)
-> SerializeTarget a
-> ViaSerializeAs a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerializeTarget a -> a
forall a. SerializeAs a => SerializeTarget a -> a
castGet (SerializeTarget a -> ViaSerializeAs a)
-> Get (SerializeTarget a) -> Get (ViaSerializeAs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get (SerializeTarget a)
forall t. Persist t => Get t
get
  {-# INLINE get #-}
  unsafeGet :: Get (ViaSerializeAs a)
unsafeGet = a -> ViaSerializeAs a
forall a. a -> ViaSerializeAs a
MkViaSerializeAs (a -> ViaSerializeAs a)
-> (SerializeTarget a -> a)
-> SerializeTarget a
-> ViaSerializeAs a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerializeTarget a -> a
forall a. SerializeAs a => SerializeTarget a -> a
castGet (SerializeTarget a -> ViaSerializeAs a)
-> Get (SerializeTarget a) -> Get (ViaSerializeAs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get (SerializeTarget a)
forall t. Persist t => Get t
unsafeGet
  {-# INLINE unsafeGet #-}

deriving via (ViaSerializeAs Word) instance HasEndianness Word
deriving via (ViaSerializeAs Int) instance HasEndianness Int
deriving via (ViaSerializeAs Word) instance Persist Word
deriving via (ViaSerializeAs Int) instance Persist Int

class ReinterpretAs a where
  type ReinterpretTarget a

newtype ViaReinterpretAs a = MkViaReinterpretAs a
  deriving (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
(ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> Eq (ViaReinterpretAs a)
forall a. Eq a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
== :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
$c/= :: forall a. Eq a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
/= :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
Eq, Eq (ViaReinterpretAs a)
Eq (ViaReinterpretAs a) =>
(ViaReinterpretAs a -> ViaReinterpretAs a -> Ordering)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> Bool)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a)
-> (ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a)
-> Ord (ViaReinterpretAs a)
ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
ViaReinterpretAs a -> ViaReinterpretAs a -> Ordering
ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
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
forall a. Ord a => Eq (ViaReinterpretAs a)
forall a. Ord a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
forall a.
Ord a =>
ViaReinterpretAs a -> ViaReinterpretAs a -> Ordering
forall a.
Ord a =>
ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
$ccompare :: forall a.
Ord a =>
ViaReinterpretAs a -> ViaReinterpretAs a -> Ordering
compare :: ViaReinterpretAs a -> ViaReinterpretAs a -> Ordering
$c< :: forall a. Ord a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
< :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
$c<= :: forall a. Ord a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
<= :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
$c> :: forall a. Ord a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
> :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
$c>= :: forall a. Ord a => ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
>= :: ViaReinterpretAs a -> ViaReinterpretAs a -> Bool
$cmax :: forall a.
Ord a =>
ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
max :: ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
$cmin :: forall a.
Ord a =>
ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
min :: ViaReinterpretAs a -> ViaReinterpretAs a -> ViaReinterpretAs a
Ord, Int -> ViaReinterpretAs a -> ShowS
[ViaReinterpretAs a] -> ShowS
ViaReinterpretAs a -> String
(Int -> ViaReinterpretAs a -> ShowS)
-> (ViaReinterpretAs a -> String)
-> ([ViaReinterpretAs a] -> ShowS)
-> Show (ViaReinterpretAs a)
forall a. Show a => Int -> ViaReinterpretAs a -> ShowS
forall a. Show a => [ViaReinterpretAs a] -> ShowS
forall a. Show a => ViaReinterpretAs a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ViaReinterpretAs a -> ShowS
showsPrec :: Int -> ViaReinterpretAs a -> ShowS
$cshow :: forall a. Show a => ViaReinterpretAs a -> String
show :: ViaReinterpretAs a -> String
$cshowList :: forall a. Show a => [ViaReinterpretAs a] -> ShowS
showList :: [ViaReinterpretAs a] -> ShowS
Show)

instance
  forall a b.
  (ReinterpretAs a, Storable a, Storable b, HasEndianness b, b ~ ReinterpretTarget a) =>
  HasEndianness (ViaReinterpretAs a)
  where
  unsafePutLE :: ViaReinterpretAs a -> Put ()
unsafePutLE (MkViaReinterpretAs a
x) = a -> Put b
forall a b. (Storable a, Storable b) => a -> Put b
reinterpretCastPut a
x Put b -> (b -> Put ()) -> Put ()
forall a b. Put a -> (a -> Put b) -> Put b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a. HasEndianness a => a -> Put ()
unsafePutLE @b
  {-# INLINE unsafePutLE #-}
  unsafePutBE :: ViaReinterpretAs a -> Put ()
unsafePutBE (MkViaReinterpretAs a
x) = a -> Put b
forall a b. (Storable a, Storable b) => a -> Put b
reinterpretCastPut a
x Put b -> (b -> Put ()) -> Put ()
forall a b. Put a -> (a -> Put b) -> Put b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a. HasEndianness a => a -> Put ()
unsafePutBE @b
  {-# INLINE unsafePutBE #-}
  unsafeGetLE :: Get (ViaReinterpretAs a)
unsafeGetLE = a -> ViaReinterpretAs a
forall a. a -> ViaReinterpretAs a
MkViaReinterpretAs (a -> ViaReinterpretAs a) -> Get a -> Get (ViaReinterpretAs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. HasEndianness a => Get a
unsafeGetLE @(ReinterpretTarget a) Get b -> (b -> Get a) -> Get a
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Get a
forall a b. (Storable a, Storable b) => a -> Get b
reinterpretCastGet)
  {-# INLINE unsafeGetLE #-}
  unsafeGetBE :: Get (ViaReinterpretAs a)
unsafeGetBE = a -> ViaReinterpretAs a
forall a. a -> ViaReinterpretAs a
MkViaReinterpretAs (a -> ViaReinterpretAs a) -> Get a -> Get (ViaReinterpretAs a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. HasEndianness a => Get a
unsafeGetBE @(ReinterpretTarget a) Get b -> (b -> Get a) -> Get a
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Get a
forall a b. (Storable a, Storable b) => a -> Get b
reinterpretCastGet)
  {-# INLINE unsafeGetBE #-}
  endiannessSize :: Int
endiannessSize = forall a. HasEndianness a => Int
endiannessSize @b

instance ReinterpretAs Double where
  type ReinterpretTarget Double = Word64

instance ReinterpretAs Float where
  type ReinterpretTarget Float = Word32

deriving via (ViaReinterpretAs Double) instance HasEndianness Double
deriving via (ViaReinterpretAs Float) instance HasEndianness Float

deriving via (LittleEndian Double) instance Persist Double
deriving via (LittleEndian Float) instance Persist Float

instance Persist Integer where
  put :: Integer -> Put ()
put Integer
n = do
    Bool -> Put ()
forall t. Persist t => t -> Put ()
put (Bool -> Put ()) -> Bool -> Put ()
forall a b. (a -> b) -> a -> b
$ Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0
    [Word8] -> Put ()
forall t. Persist t => t -> Put ()
put ([Word8] -> Put ()) -> [Word8] -> Put ()
forall a b. (a -> b) -> a -> b
$ Integer -> [Word8]
forall a. (Integral a, Bits a) => a -> [Word8]
unroll (Integer -> [Word8]) -> Integer -> [Word8]
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
abs Integer
n

  get :: Get Integer
get = do
    Bool
neg <- Get Bool
forall t. Persist t => Get t
get
    Integer
val <- [Word8] -> Integer
forall a. (Integral a, Bits a) => [Word8] -> a
roll ([Word8] -> Integer) -> Get [Word8] -> Get Integer
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [Word8]
forall t. Persist t => Get t
get
    Integer -> Get Integer
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> Get Integer) -> Integer -> Get Integer
forall a b. (a -> b) -> a -> b
$! if Bool
neg then Integer -> Integer
forall a. Num a => a -> a
negate Integer
val else Integer
val

unroll :: (Integral a, Bits a) => a -> [Word8]
unroll :: forall a. (Integral a, Bits a) => a -> [Word8]
unroll = (a -> Maybe (Word8, a)) -> a -> [Word8]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr a -> Maybe (Word8, a)
forall {b} {a}. (Integral b, Num a, Bits b) => b -> Maybe (a, b)
step
 where
  step :: b -> Maybe (a, b)
step b
0 = Maybe (a, b)
forall a. Maybe a
Nothing
  step b
i = (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (b -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral b
i, b
i b -> Int -> b
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
8)

roll :: (Integral a, Bits a) => [Word8] -> a
roll :: forall a. (Integral a, Bits a) => [Word8] -> a
roll = (Word8 -> a -> a) -> a -> [Word8] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Word8 -> a -> a
forall {a} {a}. (Bits a, Integral a, Num a) => a -> a -> a
unstep a
0
 where
  unstep :: a -> a -> a
unstep a
b a
a = a
a a -> Int -> a
forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
8 a -> a -> a
forall a. Bits a => a -> a -> a
.|. a -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
b

instance (Persist a) => Persist (Ratio a) where
  put :: Ratio a -> Put ()
put (a
n :% a
d) = a -> Put ()
forall t. Persist t => t -> Put ()
put a
n Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> a -> Put ()
forall t. Persist t => t -> Put ()
put a
d
  {-# INLINE put #-}

  get :: Get (Ratio a)
get = a -> a -> Ratio a
forall a. a -> a -> Ratio a
(:%) (a -> a -> Ratio a) -> Get a -> Get (a -> Ratio a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get a
forall t. Persist t => Get t
get Get (a -> Ratio a) -> Get a -> Get (Ratio a)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get a
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance Persist Natural where
  put :: Natural -> Put ()
put = [Word8] -> Put ()
forall t. Persist t => t -> Put ()
put ([Word8] -> Put ()) -> (Natural -> [Word8]) -> Natural -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> [Word8]
forall a. (Integral a, Bits a) => a -> [Word8]
unroll
  get :: Get Natural
get = [Word8] -> Natural
forall a. (Integral a, Bits a) => [Word8] -> a
roll ([Word8] -> Natural) -> Get [Word8] -> Get Natural
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [Word8]
forall t. Persist t => Get t
get

-- Char is serialized as UTF-8
instance Persist Char where
  put :: Char -> Put ()
put Char
a
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x7f = Int -> Put ()
grow Int
1 Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put ()
forall t. Persist t => t -> Put ()
unsafePut Char
a
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x7ff = Int -> Put ()
grow Int
2 Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put ()
forall t. Persist t => t -> Put ()
unsafePut Char
a
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xffff = Int -> Put ()
grow Int
3 Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put ()
forall t. Persist t => t -> Put ()
unsafePut Char
a
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10ffff = Int -> Put ()
grow Int
4 Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put ()
forall t. Persist t => t -> Put ()
unsafePut Char
a
    | Bool
otherwise = String -> Put ()
forall a. HasCallStack => String -> a
error String
"Not a valid Unicode code point"
   where
    c :: Int
c = Char -> Int
ord Char
a
  {-# INLINE put #-}

  unsafePut :: Char -> Put ()
unsafePut Char
a
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x7f = Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
c :: Word8)
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x7ff = do
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0xc0 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
y)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
z)
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xffff = do
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0xe0 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
y)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
z)
    | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10ffff = do
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0xf0 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
w)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
x)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
y)
        Word8 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Word8
0x80 Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.|. Word8
z)
    | Bool
otherwise = String -> Put ()
forall a. HasCallStack => String -> a
error String
"Not a valid Unicode code point"
   where
    c :: Int
c = Char -> Int
ord Char
a
    z, y, x, w :: Word8
    z :: Word8
z = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
c Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int
0x3f)
    y :: Word8
y = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR Int
c Int
6 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int
0x3f)
    x :: Word8
x = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR Int
c Int
12 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int
0x3f)
    w :: Word8
w = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftR Int
c Int
18 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int
0x7)
  {-# INLINE unsafePut #-}

  get :: Get Char
get = do
    let byte :: Get Int
byte = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Int) -> Get Word8 -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall t. Persist t => Get t
get @Word8
        shiftL6 :: Int -> Int
shiftL6 = (Int -> Int -> Int) -> Int -> Int -> Int
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> Int -> Int
forall a. Bits a => a -> Int -> a
unsafeShiftL Int
6
    Int
w <- Get Int
byte
    Int
r <-
      if
        | Int
w Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0x80 -> Int -> Get Int
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
w
        | Int
w Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0xe0 -> do
            Int
x <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int -> Get Int
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Get Int) -> Int -> Get Int
forall a b. (a -> b) -> a -> b
$ Int
x Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6 (Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0xc0 Int
w)
        | Int
w Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0xf0 -> do
            Int
x <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int
y <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int -> Get Int
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Get Int) -> Int -> Get Int
forall a b. (a -> b) -> a -> b
$
              Int
y
                Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6
                  ( Int
x
                      Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6
                        (Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0xe0 Int
w)
                  )
        | Bool
otherwise -> do
            Int
x <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int
y <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int
z <- Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0x80 (Int -> Int) -> Get Int -> Get Int
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get Int
byte
            Int -> Get Int
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Get Int) -> Int -> Get Int
forall a b. (a -> b) -> a -> b
$
              Int
z
                Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6
                  ( Int
y
                      Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6
                        (Int
x Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|. Int -> Int
shiftL6 (Int -> Int -> Int
forall a. Bits a => a -> a -> a
xor Int
0xf0 Int
w))
                  )
    if Int
r Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10FFFF
      then
        Char -> Get Char
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Char -> Get Char) -> Char -> Get Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
unsafeChr Int
r
      else
        (Int -> String -> GetException) -> String -> Get Char
forall a. (Int -> String -> GetException) -> String -> Get a
failGet Int -> String -> GetException
CharException String
"Invalid character"
  {-# INLINE get #-}

instance Persist Text where
  put :: Text -> Put ()
put = ByteString -> Put ()
forall t. Persist t => t -> Put ()
put (ByteString -> Put ()) -> (Text -> ByteString) -> Text -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
TE.encodeUtf8
  {-# INLINE put #-}
  get :: Get Text
get = do
    Int
n <- Get Int
forall t. Persist t => Get t
get
    ByteString -> Text
TE.decodeUtf8 (ByteString -> Text) -> Get ByteString -> Get Text
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Int -> Get ByteString
getBytes Int
n
  {-# INLINE get #-}

instance Persist Bool
instance Persist Ordering
instance (Persist a) => Persist (Maybe a)
instance (Persist e) => Persist (T.Tree e)
instance (Persist a, Persist b) => Persist (Either a b)
instance (Persist a, Persist b) => Persist (a, b)
instance (Persist a, Persist b, Persist c) => Persist (a, b, c)
instance
  (Persist a, Persist b, Persist c, Persist d) =>
  Persist (a, b, c, d)
instance
  (Persist a, Persist b, Persist c, Persist d, Persist e) =>
  Persist (a, b, c, d, e)
instance
  ( Persist a
  , Persist b
  , Persist c
  , Persist d
  , Persist e
  , Persist f
  ) =>
  Persist (a, b, c, d, e, f)
instance
  ( Persist a
  , Persist b
  , Persist c
  , Persist d
  , Persist e
  , Persist f
  , Persist g
  ) =>
  Persist (a, b, c, d, e, f, g)
instance (Persist a) => Persist (M.Dual a)
instance Persist M.All
instance Persist M.Any
instance (Persist a) => Persist (M.Sum a)
instance (Persist a) => Persist (M.Product a)
instance (Persist a) => Persist (M.First a)
instance (Persist a) => Persist (M.Last a)

{- | Persist a list in the following format:
  Word64 (little endian format)
  element 1
  ...
  element n
-}
instance (Persist a) => Persist [a] where
  put :: [a] -> Put ()
put [a]
l = do
    PutSize Word64
sizeHandle <- forall a. HasEndianness a => Put (PutSize a)
reserveSize @Word64
    PutSize Word64 -> Word64 -> [a] -> Put ()
forall {t} {t}.
(Integral t, HasEndianness t, Persist t) =>
PutSize t -> t -> [t] -> Put ()
go PutSize Word64
sizeHandle Word64
0 [a]
l
   where
    go :: PutSize t -> t -> [t] -> Put ()
go PutSize t
sizeHandle !t
n [] = PutSize t -> t -> Put ()
forall a. (Integral a, HasEndianness a) => PutSize a -> a -> Put ()
resolveSizeLE PutSize t
sizeHandle t
n
    go PutSize t
sizeHandle !t
n (t
x : [t]
rest) = t -> Put ()
forall t. Persist t => t -> Put ()
put t
x Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PutSize t -> t -> [t] -> Put ()
go PutSize t
sizeHandle (t
n t -> t -> t
forall a. Num a => a -> a -> a
+ t
1) [t]
rest
  {-# INLINE put #-}

  get :: Get [a]
get = [a] -> Word64 -> Get [a]
forall {t} {a}. (Eq t, Num t, Persist a) => [a] -> t -> Get [a]
go [] (Word64 -> Get [a]) -> Get Word64 -> Get [a]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall t. Persist t => Get t
get @Word64
   where
    go :: [a] -> t -> Get [a]
go [a]
as t
0 = [a] -> Get [a]
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([a] -> Get [a]) -> [a] -> Get [a]
forall a b. (a -> b) -> a -> b
$! [a] -> [a]
forall a. [a] -> [a]
reverse [a]
as
    go [a]
as t
i = do
      a
x <- Get a
forall t. Persist t => Get t
get
      a
x a -> Get [a] -> Get [a]
forall a b. a -> b -> b
`seq` [a] -> t -> Get [a]
go (a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
as) (t
i t -> t -> t
forall a. Num a => a -> a -> a
- t
1)
  {-# INLINE get #-}

instance Persist ByteString where
  put :: ByteString -> Put ()
put ByteString
s = do
    let lengthSize :: Int
lengthSize = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. HasEndianness a => Int
endiannessSize @Int)
    Int -> Put ()
grow (ByteString -> Int
B.length ByteString
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
lengthSize)
    ByteString -> Put ()
forall t. Persist t => t -> Put ()
unsafePut ByteString
s
  {-# INLINE put #-}

  unsafePut :: ByteString -> Put ()
unsafePut ByteString
s = do
    Int -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Int -> Put ()) -> Int -> Put ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
s
    ByteString -> Put ()
unsafePutByteString ByteString
s
  {-# INLINE unsafePut #-}

  get :: Get ByteString
get = Get Int
forall t. Persist t => Get t
get Get Int -> (Int -> Get ByteString) -> Get ByteString
forall a b. Get a -> (a -> Get b) -> Get b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Get ByteString
getByteString
  {-# INLINE get #-}

instance Persist L.ByteString where
  put :: ByteString -> Put ()
put ByteString
s = do
    let lengthSize :: Int64
lengthSize = Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. HasEndianness a => Int
endiannessSize @Int64)
    Int -> Put ()
grow (Int64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Int) -> Int64 -> Int
forall a b. (a -> b) -> a -> b
$ ByteString -> Int64
L.length ByteString
s Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
lengthSize)
    ByteString -> Put ()
forall t. Persist t => t -> Put ()
unsafePut ByteString
s
  {-# INLINE put #-}

  unsafePut :: ByteString -> Put ()
unsafePut ByteString
s = do
    Int64 -> Put ()
forall t. Persist t => t -> Put ()
unsafePut (Int64 -> Put ()) -> Int64 -> Put ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Int64
L.length ByteString
s
    [ByteString] -> (ByteString -> Put ()) -> Put ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (ByteString -> [ByteString]
L.toChunks ByteString
s) ByteString -> Put ()
unsafePutByteString
  {-# INLINE unsafePut #-}

  get :: Get ByteString
get = ByteString -> ByteString
L.fromStrict (ByteString -> ByteString) -> Get ByteString -> Get ByteString
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get ByteString
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance Persist S.ShortByteString where
  put :: ShortByteString -> Put ()
put ShortByteString
s = do
    let lengthSize :: Int
lengthSize = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. HasEndianness a => Int
endiannessSize @Int)
    Int -> Put ()
grow (ShortByteString -> Int
S.length ShortByteString
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
lengthSize)
    ShortByteString -> Put ()
forall t. Persist t => t -> Put ()
unsafePut ShortByteString
s

  unsafePut :: ShortByteString -> Put ()
unsafePut ShortByteString
s = do
    let n :: Int
n = ShortByteString -> Int
S.length ShortByteString
s
    Int -> Put ()
forall t. Persist t => t -> Put ()
unsafePut Int
n
    (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
      ShortByteString -> Int -> Ptr Word8 -> Int -> IO ()
forall a. ShortByteString -> Int -> Ptr a -> Int -> IO ()
S.copyToPtr ShortByteString
s Int
0 Ptr Word8
p Int
n
      (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
n Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()

  get :: Get ShortByteString
get = ByteString -> ShortByteString
S.toShort (ByteString -> ShortByteString)
-> Get ByteString -> Get ShortByteString
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get ByteString
forall t. Persist t => Get t
get

instance (Ord a, Persist a) => Persist (Set a) where
  put :: Set a -> Put ()
put = [a] -> Put ()
forall t. Persist t => t -> Put ()
put ([a] -> Put ()) -> (Set a -> [a]) -> Set a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
Set a -> [Item (Set a)]
forall l. IsList l => l -> [Item l]
toList
  {-# INLINE put #-}
  get :: Get (Set a)
get = [a] -> Set a
[Item (Set a)] -> Set a
forall l. IsList l => [Item l] -> l
fromList ([a] -> Set a) -> Get [a] -> Get (Set a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [a]
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance (Ord k, Persist k, Persist e) => Persist (Map k e) where
  put :: Map k e -> Put ()
put = [(k, e)] -> Put ()
forall t. Persist t => t -> Put ()
put ([(k, e)] -> Put ()) -> (Map k e -> [(k, e)]) -> Map k e -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k e -> [(k, e)]
Map k e -> [Item (Map k e)]
forall l. IsList l => l -> [Item l]
toList
  {-# INLINE put #-}
  get :: Get (Map k e)
get = [(k, e)] -> Map k e
[Item (Map k e)] -> Map k e
forall l. IsList l => [Item l] -> l
fromList ([(k, e)] -> Map k e) -> Get [(k, e)] -> Get (Map k e)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [(k, e)]
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance Persist IntSet where
  put :: IntSet -> Put ()
put = [Int] -> Put ()
forall t. Persist t => t -> Put ()
put ([Int] -> Put ()) -> (IntSet -> [Int]) -> IntSet -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntSet -> [Int]
IntSet -> [Item IntSet]
forall l. IsList l => l -> [Item l]
toList
  get :: Get IntSet
get = [Int] -> IntSet
[Item IntSet] -> IntSet
forall l. IsList l => [Item l] -> l
fromList ([Int] -> IntSet) -> Get [Int] -> Get IntSet
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [Int]
forall t. Persist t => Get t
get

instance (Persist e) => Persist (NonEmpty e) where
  put :: NonEmpty e -> Put ()
put = [e] -> Put ()
forall t. Persist t => t -> Put ()
put ([e] -> Put ()) -> (NonEmpty e -> [e]) -> NonEmpty e -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty e -> [e]
NonEmpty e -> [Item (NonEmpty e)]
forall l. IsList l => l -> [Item l]
toList
  {-# INLINE put #-}
  get :: Get (NonEmpty e)
get = [e] -> NonEmpty e
[Item (NonEmpty e)] -> NonEmpty e
forall l. IsList l => [Item l] -> l
fromList ([e] -> NonEmpty e) -> Get [e] -> Get (NonEmpty e)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [e]
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance (Persist e) => Persist (IntMap e) where
  put :: IntMap e -> Put ()
put = [(Int, e)] -> Put ()
forall t. Persist t => t -> Put ()
put ([(Int, e)] -> Put ())
-> (IntMap e -> [(Int, e)]) -> IntMap e -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntMap e -> [(Int, e)]
IntMap e -> [Item (IntMap e)]
forall l. IsList l => l -> [Item l]
toList
  {-# INLINE put #-}
  get :: Get (IntMap e)
get = [(Int, e)] -> IntMap e
[Item (IntMap e)] -> IntMap e
forall l. IsList l => [Item l] -> l
fromList ([(Int, e)] -> IntMap e) -> Get [(Int, e)] -> Get (IntMap e)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [(Int, e)]
forall t. Persist t => Get t
get
  {-# INLINE get #-}

instance (Persist e) => Persist (Seq e) where
  put :: Seq e -> Put ()
put = [e] -> Put ()
forall t. Persist t => t -> Put ()
put ([e] -> Put ()) -> (Seq e -> [e]) -> Seq e -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq e -> [e]
Seq e -> [Item (Seq e)]
forall l. IsList l => l -> [Item l]
toList
  {-# INLINE put #-}
  get :: Get (Seq e)
get = [e] -> Seq e
[Item (Seq e)] -> Seq e
forall l. IsList l => [Item l] -> l
fromList ([e] -> Seq e) -> Get [e] -> Get (Seq e)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get [e]
forall t. Persist t => Get t
get
  {-# INLINE get #-}

type family SumArity (a :: Type -> Type) :: Nat where
  SumArity (C1 c a) = 1
  SumArity (x :+: y) = SumArity x + SumArity y

class GPersistPut f where
  gput :: f a -> Put ()

class GPersistGet f where
  gget :: Get (f a)

instance (GPersistPut f) => GPersistPut (M1 i c f) where
  gput :: forall a. M1 i c f a -> Put ()
gput = f a -> Put ()
forall a. f a -> Put ()
forall (f :: * -> *) a. GPersistPut f => f a -> Put ()
gput (f a -> Put ()) -> (M1 i c f a -> f a) -> M1 i c f a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i c f a -> f a
forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1
  {-# INLINE gput #-}

instance (GPersistGet f) => GPersistGet (M1 i c f) where
  gget :: forall a. Get (M1 i c f a)
gget = (f a -> M1 i c f a) -> Get (f a) -> Get (M1 i c f a)
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> M1 i c f a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 Get (f a)
forall a. Get (f a)
forall (f :: * -> *) a. GPersistGet f => Get (f a)
gget
  {-# INLINE gget #-}

instance (Persist a) => GPersistPut (K1 i a) where
  gput :: forall a. K1 i a a -> Put ()
gput = a -> Put ()
forall t. Persist t => t -> Put ()
put (a -> Put ()) -> (K1 i a a -> a) -> K1 i a a -> Put ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. K1 i a a -> a
forall k i c (p :: k). K1 i c p -> c
unK1
  {-# INLINE gput #-}

instance (Persist a) => GPersistGet (K1 i a) where
  gget :: forall a. Get (K1 i a a)
gget = (a -> K1 i a a) -> Get a -> Get (K1 i a a)
forall a b. (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> K1 i a a
forall k i c (p :: k). c -> K1 i c p
K1 Get a
forall t. Persist t => Get t
get
  {-# INLINE gget #-}

instance GPersistPut U1 where
  gput :: forall a. U1 a -> Put ()
gput U1 a
_ = () -> Put ()
forall a. a -> Put a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  {-# INLINE gput #-}

instance GPersistGet U1 where
  gget :: forall a. Get (U1 a)
gget = U1 a -> Get (U1 a)
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1
  {-# INLINE gget #-}

instance GPersistPut V1 where
  gput :: forall a. V1 a -> Put ()
gput V1 a
x = case V1 a
x of {}
  {-# INLINE gput #-}

instance GPersistGet V1 where
  gget :: forall a. Get (V1 a)
gget = Get (V1 a)
forall a. HasCallStack => a
undefined
  {-# INLINE gget #-}

instance (GPersistPut a, GPersistPut b) => GPersistPut (a :*: b) where
  gput :: forall a. (:*:) a b a -> Put ()
gput (a a
a :*: b a
b) = a a -> Put ()
forall a. a a -> Put ()
forall (f :: * -> *) a. GPersistPut f => f a -> Put ()
gput a a
a Put () -> Put () -> Put ()
forall a b. Put a -> Put b -> Put b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> b a -> Put ()
forall a. b a -> Put ()
forall (f :: * -> *) a. GPersistPut f => f a -> Put ()
gput b a
b
  {-# INLINE gput #-}

instance (GPersistGet a, GPersistGet b) => GPersistGet (a :*: b) where
  gget :: forall a. Get ((:*:) a b a)
gget = a a -> b a -> (:*:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (a a -> b a -> (:*:) a b a)
-> Get (a a) -> Get (b a -> (:*:) a b a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Get (a a)
forall a. Get (a a)
forall (f :: * -> *) a. GPersistGet f => Get (f a)
gget Get (b a -> (:*:) a b a) -> Get (b a) -> Get ((:*:) a b a)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get (b a)
forall a. Get (b a)
forall (f :: * -> *) a. GPersistGet f => Get (f a)
gget
  {-# INLINE gget #-}

instance (FitsInByte (SumArity (a :+: b)), GPersistPutSum 0 (a :+: b)) => GPersistPut (a :+: b) where
  gput :: forall a. (:+:) a b a -> Put ()
gput (:+:) a b a
x = (:+:) a b a -> Proxy 0 -> Put ()
forall (n :: Natural) (f :: * -> *) p.
GPersistPutSum n f =>
f p -> Proxy n -> Put ()
forall p. (:+:) a b p -> Proxy 0 -> Put ()
gputSum (:+:) a b a
x (Proxy 0
forall {k} (t :: k). Proxy t
Proxy :: Proxy 0)
  {-# INLINE gput #-}

instance (FitsInByte (SumArity (a :+: b)), GPersistGetSum 0 (a :+: b)) => GPersistGet (a :+: b) where
  gget :: forall a. Get ((:+:) a b a)
gget = do
    Word8
tag <- Get Word8
forall t. Persist t => Get t
get
    Word8 -> Proxy 0 -> Get ((:+:) a b a)
forall (n :: Natural) (f :: * -> *) p.
GPersistGetSum n f =>
Word8 -> Proxy n -> Get (f p)
forall p. Word8 -> Proxy 0 -> Get ((:+:) a b p)
ggetSum Word8
tag (Proxy 0
forall {k} (t :: k). Proxy t
Proxy :: Proxy 0)
  {-# INLINE gget #-}

type FitsInByte n = FitsInByteResult (n <=? 255)

type family FitsInByteResult (b :: Bool) :: Constraint where
  FitsInByteResult 'True = ()
  FitsInByteResult 'False =
    TypeErrorMessage
      "Generic deriving of Persist instances can only be used on datatypes with fewer than 256 constructors."

type family TypeErrorMessage (a :: Symbol) :: Constraint where
  TypeErrorMessage a = TypeError ('Text a)

class (KnownNat n) => GPersistPutSum (n :: Nat) (f :: Type -> Type) where
  gputSum :: f p -> Proxy n -> Put ()

class (KnownNat n) => GPersistGetSum (n :: Nat) (f :: Type -> Type) where
  ggetSum :: Word8 -> Proxy n -> Get (f p)

instance
  (GPersistPutSum n a, GPersistPutSum (n + SumArity a) b, KnownNat n) =>
  GPersistPutSum n (a :+: b)
  where
  gputSum :: forall p. (:+:) a b p -> Proxy n -> Put ()
gputSum (L1 a p
l) Proxy n
_ = a p -> Proxy n -> Put ()
forall (n :: Natural) (f :: * -> *) p.
GPersistPutSum n f =>
f p -> Proxy n -> Put ()
forall p. a p -> Proxy n -> Put ()
gputSum a p
l (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
  gputSum (R1 b p
r) Proxy n
_ = b p -> Proxy (n + SumArity a) -> Put ()
forall (n :: Natural) (f :: * -> *) p.
GPersistPutSum n f =>
f p -> Proxy n -> Put ()
forall p. b p -> Proxy (n + SumArity a) -> Put ()
gputSum b p
r (Proxy (n + SumArity a)
forall {k} (t :: k). Proxy t
Proxy :: Proxy (n + SumArity a))
  {-# INLINE gputSum #-}

instance
  (GPersistGetSum n a, GPersistGetSum (n + SumArity a) b, KnownNat n) =>
  GPersistGetSum n (a :+: b)
  where
  ggetSum :: forall p. Word8 -> Proxy n -> Get ((:+:) a b p)
ggetSum Word8
tag Proxy n
proxyL
    | Word8
tag Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
sizeL = a p -> (:+:) a b p
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (a p -> (:+:) a b p) -> Get (a p) -> Get ((:+:) a b p)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word8 -> Proxy n -> Get (a p)
forall (n :: Natural) (f :: * -> *) p.
GPersistGetSum n f =>
Word8 -> Proxy n -> Get (f p)
forall p. Word8 -> Proxy n -> Get (a p)
ggetSum Word8
tag Proxy n
proxyL
    | Bool
otherwise = b p -> (:+:) a b p
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (b p -> (:+:) a b p) -> Get (b p) -> Get ((:+:) a b p)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word8 -> Proxy (n + SumArity a) -> Get (b p)
forall (n :: Natural) (f :: * -> *) p.
GPersistGetSum n f =>
Word8 -> Proxy n -> Get (f p)
forall p. Word8 -> Proxy (n + SumArity a) -> Get (b p)
ggetSum Word8
tag (Proxy (n + SumArity a)
forall {k} (t :: k). Proxy t
Proxy :: Proxy (n + SumArity a))
   where
    sizeL :: Word8
sizeL = Integer -> Word8
forall a. Num a => Integer -> a
fromInteger (Proxy (n + SumArity a) -> Integer
forall (n :: Natural) (proxy :: Natural -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy (n + SumArity a)
forall {k} (t :: k). Proxy t
Proxy :: Proxy (n + SumArity a)))
  {-# INLINE ggetSum #-}

instance (GPersistPut a, KnownNat n) => GPersistPutSum n (C1 c a) where
  gputSum :: forall p. C1 c a p -> Proxy n -> Put ()
gputSum C1 c a p
x Proxy n
_ = do
    Word8 -> Put ()
forall t. Persist t => t -> Put ()
put (Integer -> Word8
forall a. Num a => Integer -> a
fromInteger (Proxy n -> Integer
forall (n :: Natural) (proxy :: Natural -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n)) :: Word8)
    C1 c a p -> Put ()
forall a. M1 C c a a -> Put ()
forall (f :: * -> *) a. GPersistPut f => f a -> Put ()
gput C1 c a p
x
  {-# INLINE gputSum #-}

instance (GPersistGet a, KnownNat n) => GPersistGetSum n (C1 c a) where
  ggetSum :: forall p. Word8 -> Proxy n -> Get (C1 c a p)
ggetSum Word8
tag Proxy n
_
    | Word8
tag Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
cur = Get (M1 C c a p)
forall a. Get (M1 C c a a)
forall (f :: * -> *) a. GPersistGet f => Get (f a)
gget
    | Word8
tag Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
> Word8
cur = String -> Get (M1 C c a p)
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Sum tag invalid"
    | Bool
otherwise = String -> Get (M1 C c a p)
forall a. String -> Get a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Implementation error"
   where
    cur :: Word8
cur = Integer -> Word8
forall a. Num a => Integer -> a
fromInteger (Proxy n -> Integer
forall (n :: Natural) (proxy :: Natural -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n
forall {k} (t :: k). Proxy t
Proxy :: Proxy n))
  {-# INLINE ggetSum #-}

-- | Ensure that @n@ bytes are available. Fails if fewer than @n@ bytes are available.
ensure :: Int -> Get ()
ensure :: Int -> Get ()
ensure Int
n
  | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = (Int -> String -> GetException) -> String -> Get ()
forall a. (Int -> String -> GetException) -> String -> Get a
failGet Int -> String -> GetException
LengthException String
"ensure: negative length"
  | Bool
otherwise = do
      Int
m <- Get Int
remaining
      Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n) (Get () -> Get ()) -> Get () -> Get ()
forall a b. (a -> b) -> a -> b
$ (Int -> String -> GetException) -> String -> Get ()
forall a. (Int -> String -> GetException) -> String -> Get a
failGet Int -> String -> GetException
LengthException String
"Not enough bytes available"
{-# INLINE ensure #-}

-- | Skip ahead @n@ bytes. Fails if fewer than @n@ bytes are available.
skip :: Int -> Get ()
skip :: Int -> Get ()
skip Int
n = do
  Int -> Get ()
ensure Int
n
  (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Get ()
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Get ())
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Get ()
forall a b. (a -> b) -> a -> b
$ \GetEnv
_ Ptr Word8
p -> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
n Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE skip #-}

{- | Get the number of remaining unparsed bytes.  Useful for checking whether
all input has been consumed.
-}
remaining :: Get Int
remaining :: Get Int
remaining = (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: Int)) -> Get Int
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: Int)) -> Get Int)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: Int)) -> Get Int
forall a b. (a -> b) -> a -> b
$ \GetEnv
e Ptr Word8
p -> (Ptr Word8 :!: Int) -> IO (Ptr Word8 :!: Int)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: Int) -> IO (Ptr Word8 :!: Int))
-> (Ptr Word8 :!: Int) -> IO (Ptr Word8 :!: Int)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8 :!: Int
forall a b. a -> b -> a :!: b
:!: GetEnv
e.end Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Word8
p
{-# INLINE remaining #-}

-- -- | Succeed if end of input reached.
eof :: Get ()
eof :: Get ()
eof = do
  Int
n <- Get Int
remaining
  Bool -> Get () -> Get ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0) (Get () -> Get ()) -> Get () -> Get ()
forall a b. (a -> b) -> a -> b
$ (Int -> String -> GetException) -> String -> Get ()
forall a. (Int -> String -> GetException) -> String -> Get a
failGet Int -> String -> GetException
EOFException String
"Expected end of file"
{-# INLINE eof #-}

-- | Pull @n@ bytes from the input, as a strict ByteString.
getBytes :: Int -> Get ByteString
getBytes :: Int -> Get ByteString
getBytes Int
n = do
  Int -> Get ()
ensure Int
n
  (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ByteString))
-> Get ByteString
forall a. (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Get a
Get ((GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ByteString))
 -> Get ByteString)
-> (GetEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ByteString))
-> Get ByteString
forall a b. (a -> b) -> a -> b
$ \GetEnv
e Ptr Word8
p -> (Ptr Word8 :!: ByteString) -> IO (Ptr Word8 :!: ByteString)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ByteString) -> IO (Ptr Word8 :!: ByteString))
-> (Ptr Word8 :!: ByteString) -> IO (Ptr Word8 :!: ByteString)
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
n Ptr Word8 -> ByteString -> Ptr Word8 :!: ByteString
forall a b. a -> b -> a :!: b
:!: ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS GetEnv
e.buf (Ptr Word8
p Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` GetEnv
e.begin) Int
n
{-# INLINE getBytes #-}

{- | An efficient 'get' method for strict ByteStrings. Fails if fewer
than @n@ bytes are left in the input. This function creates a fresh
copy of the underlying bytes.
-}
getByteString :: Int -> Get ByteString
getByteString :: Int -> Get ByteString
getByteString Int
n = ByteString -> ByteString
B.copy (ByteString -> ByteString) -> Get ByteString -> Get ByteString
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Int -> Get ByteString
getBytes Int
n
{-# INLINE getByteString #-}

{- | An efficient 'get' method to apply a recursive 'get' to a substring of
known length.
-}
getPrefix :: Int -> Get a -> Get a
getPrefix :: forall a. Int -> Get a -> Get a
getPrefix Int
prefixLength Get a
baseGet = do
  Int -> Get ()
ensure Int
prefixLength
  Int -> Get a -> Get a
forall a. Int -> Get a -> Get a
unsafeGetPrefix Int
prefixLength Get a
baseGet

runPut :: Put a -> ByteString
runPut :: forall a. Put a -> ByteString
runPut = (a, ByteString) -> ByteString
forall a b. (a, b) -> b
snd ((a, ByteString) -> ByteString)
-> (Put a -> (a, ByteString)) -> Put a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Put a -> (a, ByteString)
forall a. Put a -> (a, ByteString)
evalPut
{-# INLINE runPut #-}

runPutLazy :: Put a -> L.ByteString
runPutLazy :: forall a. Put a -> ByteString
runPutLazy = (a, ByteString) -> ByteString
forall a b. (a, b) -> b
snd ((a, ByteString) -> ByteString)
-> (Put a -> (a, ByteString)) -> Put a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Put a -> (a, ByteString)
forall a. Put a -> (a, ByteString)
evalPutLazy
{-# INLINE runPutLazy #-}

putByteString :: ByteString -> Put ()
putByteString :: ByteString -> Put ()
putByteString ByteString
bs = do
  Int -> Put ()
grow (ByteString -> Int
B.length ByteString
bs)
  ByteString -> Put ()
unsafePutByteString ByteString
bs

unsafePutByteString :: ByteString -> Put ()
unsafePutByteString :: ByteString -> Put ()
unsafePutByteString (B.PS ForeignPtr Word8
b Int
o Int
n) = do
  (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
_ Ptr Word8
p -> do
    ForeignPtr Word8 -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Word8
b ((Ptr Word8 -> IO ()) -> IO ()) -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
q -> Ptr Word8 -> Ptr Word8 -> Int -> IO ()
forall a. Ptr a -> Ptr a -> Int -> IO ()
copyBytes Ptr Word8
p (Ptr Word8
q Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
o) Int
n
    (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$! Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
n Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()
{-# INLINE putByteString #-}

{- | Reserve a length value that can be filled in later. The length
  value itself must have a fixed size.
-}
reserveSize :: forall a. (HasEndianness a) => Put (PutSize a)
reserveSize :: forall a. HasEndianness a => Put (PutSize a)
reserveSize = do
  Int -> Put ()
grow Int
sizeSize
  Put (PutSize a)
doWrite
 where
  sizeSize :: Int
sizeSize = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ forall a. HasEndianness a => Int
endiannessSize @a
  doWrite :: Put (PutSize a)
doWrite = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: PutSize a))
-> Put (PutSize a)
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: PutSize a))
 -> Put (PutSize a))
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: PutSize a))
-> Put (PutSize a)
forall a b. (a -> b) -> a -> b
$ \PutEnv
e Ptr Word8
p -> do
    let p' :: Ptr Word8
p' = Ptr Word8
p Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
sizeSize
    (Chunk
c :| [Chunk]
_) <- IORef (NonEmpty Chunk) -> IO (NonEmpty Chunk)
forall a. IORef a -> IO a
readIORef PutEnv
e.chunks
    (Ptr Word8 :!: PutSize a) -> IO (Ptr Word8 :!: PutSize a)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: PutSize a) -> IO (Ptr Word8 :!: PutSize a))
-> (Ptr Word8 :!: PutSize a) -> IO (Ptr Word8 :!: PutSize a)
forall a b. (a -> b) -> a -> b
$!
      Ptr Word8
p'
        Ptr Word8 -> PutSize a -> Ptr Word8 :!: PutSize a
forall a b. a -> b -> a :!: b
:!: PutSize
          { sizePtr :: Ptr Word8
sizePtr = Ptr Word8
p
          , sizeStart :: Ptr Word8
sizeStart = Ptr Word8
p'
          , chunkStart :: Ptr Word8
chunkStart = Chunk
c.begin
          }

{- | Backpatch a computed length value, excluding the bytes for the length
  itself.
-}
resolveSizeExclusive :: forall a. (Integral a, HasEndianness a) => (a -> Put ()) -> PutSize a -> Put ()
resolveSizeExclusive :: forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeExclusive a -> Put ()
putter PutSize {Ptr Word8
sizePtr :: forall a. PutSize a -> Ptr Word8
sizeStart :: forall a. PutSize a -> Ptr Word8
chunkStart :: forall a. PutSize a -> Ptr Word8
sizePtr :: Ptr Word8
sizeStart :: Ptr Word8
chunkStart :: Ptr Word8
..} = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
e Ptr Word8
p -> do
  a
writeSize <- PutEnv -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO a
forall a.
(Integral a, HasEndianness a) =>
PutEnv -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO a
computeSize PutEnv
e Ptr Word8
chunkStart Ptr Word8
sizeStart Ptr Word8
p
  Ptr Word8 :!: ()
_ <- (a -> Put ()
putter a
writeSize).unPut PutEnv
e Ptr Word8
sizePtr
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$ Ptr Word8
p Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()

resolveSizeInclusive :: forall a. (Integral a, HasEndianness a) => (a -> Put ()) -> PutSize a -> Put ()
resolveSizeInclusive :: forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeInclusive a -> Put ()
putter PutSize {Ptr Word8
sizePtr :: forall a. PutSize a -> Ptr Word8
sizeStart :: forall a. PutSize a -> Ptr Word8
chunkStart :: forall a. PutSize a -> Ptr Word8
sizePtr :: Ptr Word8
sizeStart :: Ptr Word8
chunkStart :: Ptr Word8
..} = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
e Ptr Word8
p -> do
  a
writeSize <- PutEnv -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO a
forall a.
(Integral a, HasEndianness a) =>
PutEnv -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO a
computeSize PutEnv
e Ptr Word8
chunkStart Ptr Word8
sizePtr Ptr Word8
p
  Ptr Word8 :!: ()
_ <- (a -> Put ()
putter a
writeSize).unPut PutEnv
e Ptr Word8
sizePtr
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$ Ptr Word8
p Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()

resolveSize :: forall a. (Integral a, HasEndianness a) => (a -> Put ()) -> PutSize a -> a -> Put ()
resolveSize :: forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> a -> Put ()
resolveSize a -> Put ()
putter PutSize {Ptr Word8
sizePtr :: forall a. PutSize a -> Ptr Word8
sizeStart :: forall a. PutSize a -> Ptr Word8
chunkStart :: forall a. PutSize a -> Ptr Word8
sizePtr :: Ptr Word8
sizeStart :: Ptr Word8
chunkStart :: Ptr Word8
..} a
manualSize = (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a. (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: a)) -> Put a
Put ((PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ())
-> (PutEnv -> Ptr Word8 -> IO (Ptr Word8 :!: ())) -> Put ()
forall a b. (a -> b) -> a -> b
$ \PutEnv
e Ptr Word8
p -> do
  Ptr Word8 :!: ()
_ <- (a -> Put ()
putter a
manualSize).unPut PutEnv
e Ptr Word8
sizePtr
  (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ()))
-> (Ptr Word8 :!: ()) -> IO (Ptr Word8 :!: ())
forall a b. (a -> b) -> a -> b
$ Ptr Word8
p Ptr Word8 -> () -> Ptr Word8 :!: ()
forall a b. a -> b -> a :!: b
:!: ()

computeSize ::
  forall a.
  (Integral a, HasEndianness a) =>
  PutEnv ->
  Ptr Word8 ->
  Ptr Word8 ->
  Ptr Word8 ->
  IO a
computeSize :: forall a.
(Integral a, HasEndianness a) =>
PutEnv -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO a
computeSize PutEnv
env Ptr Word8
chunkStartPtr Ptr Word8
basePtr Ptr Word8
finalPtr = do
  (Chunk
chunk :| [Chunk]
chunks) <- IORef (NonEmpty Chunk) -> IO (NonEmpty Chunk)
forall a. IORef a -> IO a
readIORef PutEnv
env.chunks
  if Ptr Word8
chunkStartPtr Ptr Word8 -> Ptr Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Chunk
chunk.begin
    then a -> IO a
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> IO a) -> (Int -> a) -> Int -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> IO a) -> Int -> IO a
forall a b. (a -> b) -> a -> b
$! Ptr Word8
finalPtr Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Word8
basePtr
    else a -> IO a
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> IO a) -> a -> IO a
forall a b. (a -> b) -> a -> b
$ [Chunk] -> Int -> a
loop [Chunk]
chunks (Ptr Word8
finalPtr Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Chunk
chunk.begin)
 where
  loop :: [Chunk] -> Int -> a
  loop :: [Chunk] -> Int -> a
loop [] !Int
_acc = PutException -> a
forall a e. Exception e => e -> a
throw PutException
PutSizeMissingStartChunk
  loop (Chunk
chunk : [Chunk]
_) !Int
acc
    | Chunk
chunk.begin Ptr Word8 -> Ptr Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Word8
chunkStartPtr =
        Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Chunk
chunk.end Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Ptr Word8
basePtr)
  loop (Chunk
chunk : [Chunk]
rest) !Int
acc =
    [Chunk] -> Int -> a
loop [Chunk]
rest (Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Chunk
chunk.end Ptr Word8 -> Ptr Word8 -> Int
forall a b. Ptr a -> Ptr b -> Int
`minusPtr` Chunk
chunk.begin))

resolveSizeExclusiveBE :: (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeExclusiveBE :: forall a. (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeExclusiveBE = (a -> Put ()) -> PutSize a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeExclusive a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutBE

resolveSizeExclusiveLE :: (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeExclusiveLE :: forall a. (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeExclusiveLE = (a -> Put ()) -> PutSize a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeExclusive a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutLE

resolveSizeInclusiveBE :: (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeInclusiveBE :: forall a. (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeInclusiveBE = (a -> Put ()) -> PutSize a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeInclusive a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutBE

resolveSizeInclusiveLE :: (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeInclusiveLE :: forall a. (Integral a, HasEndianness a) => PutSize a -> Put ()
resolveSizeInclusiveLE = (a -> Put ()) -> PutSize a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> Put ()
resolveSizeInclusive a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutLE

resolveSizeLE :: (Integral a, HasEndianness a) => PutSize a -> a -> Put()
resolveSizeLE :: forall a. (Integral a, HasEndianness a) => PutSize a -> a -> Put ()
resolveSizeLE = (a -> Put ()) -> PutSize a -> a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> a -> Put ()
resolveSize a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutLE

resolveSizeBE :: (Integral a, HasEndianness a) => PutSize a -> a -> Put()
resolveSizeBE :: forall a. (Integral a, HasEndianness a) => PutSize a -> a -> Put ()
resolveSizeBE = (a -> Put ()) -> PutSize a -> a -> Put ()
forall a.
(Integral a, HasEndianness a) =>
(a -> Put ()) -> PutSize a -> a -> Put ()
resolveSize a -> Put ()
forall a. HasEndianness a => a -> Put ()
unsafePutBE