module Unison.Runtime.Serialize.Get
  ( Get (..),
    GetExn (..),
    getExnMsg,
    PrimBase (..),
    Ix (..),
    evaluated,
    getByteString,
    getWord8,
    getVarInt,
    getInt64be,
    getWord16be,
    getWord32be,
    getWord64be,
    getWord64le,
    getDoublebe,
    getFloatbe,
    getAccumulating,
    getAccumulatingRevList,
    getArray,
    getList,
    getSeq,
    getPrimArray,
    remaining,
    runGet,
    runGetCatch,
    runGetCatchIO,
  )
where

import Control.Exception
import Control.Monad (replicateM)
import Control.Monad.Primitive
import Control.Monad.ST
import Control.Monad.Trans (MonadTrans (..))
import Data.Bifunctor (first)
import Data.Bits
import Data.ByteString as BS
import Data.ByteString.Unsafe qualified as BS
import Data.Int
import Data.Primitive.Array
import Data.Primitive.PrimArray
import Data.Primitive.PrimVar
import Data.Primitive.Types
import Data.Sequence qualified as Seq
import Data.Word

-- TODO: replace with GHC builtins after upgrading to GHC 9.10
foreign import ccall unisonWord32ToFloat :: Word32 -> Float

foreign import ccall unisonWord64ToDouble :: Word64 -> Double

newtype Ix m = Ix (PrimVar (PrimState m) Int)

newtype Get m a = Get {forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet :: ByteString -> Ix m -> m a}

runGet :: (PrimBase m) => Get m a -> ByteString -> m a
runGet :: forall (m :: * -> *) a. PrimBase m => Get m a -> ByteString -> m a
runGet (Get ByteString -> Ix m -> m a
k) ByteString
bs = Int -> m (PrimVar (PrimState m) Int)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
a -> m (PrimVar (PrimState m) a)
newPrimVar Int
0 m (PrimVar (PrimState m) Int)
-> (PrimVar (PrimState m) Int -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ByteString -> Ix m -> m a
k ByteString
bs (Ix m -> m a)
-> (PrimVar (PrimState m) Int -> Ix m)
-> PrimVar (PrimState m) Int
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimVar (PrimState m) Int -> Ix m
forall (m :: * -> *). PrimVar (PrimState m) Int -> Ix m
Ix
{-# SPECIALIZE runGet :: Get IO a -> ByteString -> IO a #-}
{-# SPECIALIZE runGet :: Get (ST s) a -> ByteString -> ST s a #-}

runGetCatchIO :: Get IO a -> ByteString -> IO (Either String a)
runGetCatchIO :: forall a. Get IO a -> ByteString -> IO (Either [Char] a)
runGetCatchIO Get IO a
g ByteString
bs = (Either GetExn a -> Either [Char] a)
-> IO (Either GetExn a) -> IO (Either [Char] a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((GetExn -> [Char]) -> Either GetExn a -> Either [Char] a
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first GetExn -> [Char]
getExnMsg) (IO (Either GetExn a) -> IO (Either [Char] a))
-> (IO a -> IO (Either GetExn a)) -> IO a -> IO (Either [Char] a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> IO (Either GetExn a)
forall e a. Exception e => IO a -> IO (Either e a)
try (IO a -> IO (Either [Char] a)) -> IO a -> IO (Either [Char] a)
forall a b. (a -> b) -> a -> b
$ Get IO a -> ByteString -> IO a
forall (m :: * -> *) a. PrimBase m => Get m a -> ByteString -> m a
runGet Get IO a
g ByteString
bs

-- This might be somewhat unsafe. It uses IO facilities to catch
-- exceptions in an ST-like monad. When in doubt, prefer `runGetCatchIO`.
runGetCatch ::
  (PrimBase m) => Get m a -> ByteString -> m (Either String a)
runGetCatch :: forall (m :: * -> *) a.
PrimBase m =>
Get m a -> ByteString -> m (Either [Char] a)
runGetCatch Get m a
g ByteString
bs =
  IO (Either [Char] a) -> m (Either [Char] a)
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim
    (IO (Either [Char] a) -> m (Either [Char] a))
-> (m a -> IO (Either [Char] a)) -> m a -> m (Either [Char] a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either GetExn a -> Either [Char] a)
-> IO (Either GetExn a) -> IO (Either [Char] a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((GetExn -> [Char]) -> Either GetExn a -> Either [Char] a
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first GetExn -> [Char]
getExnMsg)
    (IO (Either GetExn a) -> IO (Either [Char] a))
-> (m a -> IO (Either GetExn a)) -> m a -> IO (Either [Char] a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> IO (Either GetExn a)
forall e a. Exception e => IO a -> IO (Either e a)
try
    (IO a -> IO (Either GetExn a))
-> (m a -> IO a) -> m a -> IO (Either GetExn a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> IO a
forall (m :: * -> *) a. PrimBase m => m a -> IO a
unsafePrimToIO
    (m a -> m (Either [Char] a)) -> m a -> m (Either [Char] a)
forall a b. (a -> b) -> a -> b
$ Get m a -> ByteString -> m a
forall (m :: * -> *) a. PrimBase m => Get m a -> ByteString -> m a
runGet Get m a
g ByteString
bs
-- runGetCatch @IO should just be safer to run as runGetCatchIO
{-# NOINLINE [1] runGetCatch #-}

{-# RULES "runGetCatch/IO" runGetCatch = runGetCatchIO #-}

evaluated :: (PrimBase m) => a -> Get m a
evaluated :: forall (m :: * -> *) a. PrimBase m => a -> Get m a
evaluated a
x = (ByteString -> Ix m -> m a) -> Get m a
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
_ Ix m
_ -> a -> m a
forall a (m :: * -> *). PrimMonad m => a -> m a
evalPrim a
x
{-# INLINE evaluated #-}

data GetExn
  = InsufficientBytes String
  | UserExn String
  deriving (Int -> GetExn -> ShowS
[GetExn] -> ShowS
GetExn -> [Char]
(Int -> GetExn -> ShowS)
-> (GetExn -> [Char]) -> ([GetExn] -> ShowS) -> Show GetExn
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GetExn -> ShowS
showsPrec :: Int -> GetExn -> ShowS
$cshow :: GetExn -> [Char]
show :: GetExn -> [Char]
$cshowList :: [GetExn] -> ShowS
showList :: [GetExn] -> ShowS
Show)

getExnMsg :: GetExn -> String
getExnMsg :: GetExn -> [Char]
getExnMsg (InsufficientBytes [Char]
name) = [Char]
"insufficient bytes in " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
name
getExnMsg (UserExn [Char]
msg) = [Char]
msg

instance Exception GetExn

instance (Functor m) => Functor (Get m) where
  fmap :: forall a b. (a -> b) -> Get m a -> Get m b
fmap a -> b
f (Get ByteString -> Ix m -> m a
k) = (ByteString -> Ix m -> m b) -> Get m b
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> (a -> b) -> m a -> m b
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (ByteString -> Ix m -> m a
k ByteString
b Ix m
i)
  {-# INLINE fmap #-}
  a
x <$ :: forall a b. a -> Get m b -> Get m a
<$ Get ByteString -> Ix m -> m b
k = (ByteString -> Ix m -> m a) -> Get m a
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> a
x a -> m b -> m a
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Ix m -> m b
k ByteString
b Ix m
i
  {-# INLINE (<$) #-}

instance (Applicative m) => Applicative (Get m) where
  pure :: forall a. a -> Get m a
pure a
x = (ByteString -> Ix m -> m a) -> Get m a
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
_ Ix m
_ -> a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x
  {-# INLINE pure #-}
  Get ByteString -> Ix m -> m (a -> b)
kf <*> :: forall a b. Get m (a -> b) -> Get m a -> Get m b
<*> Get ByteString -> Ix m -> m a
kx = (ByteString -> Ix m -> m b) -> Get m b
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> ByteString -> Ix m -> m (a -> b)
kf ByteString
b Ix m
i m (a -> b) -> m a -> m b
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> Ix m -> m a
kx ByteString
b Ix m
i
  {-# INLINE (<*>) #-}
  liftA2 :: forall a b c. (a -> b -> c) -> Get m a -> Get m b -> Get m c
liftA2 a -> b -> c
f (Get ByteString -> Ix m -> m a
kx) (Get ByteString -> Ix m -> m b
ky) = (ByteString -> Ix m -> m c) -> Get m c
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> (a -> b -> c) -> m a -> m b -> m c
forall a b c. (a -> b -> c) -> m a -> m b -> m c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> b -> c
f (ByteString -> Ix m -> m a
kx ByteString
b Ix m
i) (ByteString -> Ix m -> m b
ky ByteString
b Ix m
i)
  {-# INLINE liftA2 #-}
  Get ByteString -> Ix m -> m a
kx *> :: forall a b. Get m a -> Get m b -> Get m b
*> Get ByteString -> Ix m -> m b
ky = (ByteString -> Ix m -> m b) -> Get m b
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> ByteString -> Ix m -> m a
kx ByteString
b Ix m
i m a -> m b -> m b
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ByteString -> Ix m -> m b
ky ByteString
b Ix m
i
  {-# INLINE (*>) #-}
  Get ByteString -> Ix m -> m a
kx <* :: forall a b. Get m a -> Get m b -> Get m a
<* Get ByteString -> Ix m -> m b
ky = (ByteString -> Ix m -> m a) -> Get m a
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> ByteString -> Ix m -> m a
kx ByteString
b Ix m
i m a -> m b -> m a
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ByteString -> Ix m -> m b
ky ByteString
b Ix m
i
  {-# INLINE (<*) #-}

instance (Monad m) => Monad (Get m) where
  Get ByteString -> Ix m -> m a
k >>= :: forall a b. Get m a -> (a -> Get m b) -> Get m b
>>= a -> Get m b
f = (ByteString -> Ix m -> m b) -> Get m b
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
b Ix m
i -> ByteString -> Ix m -> m a
k ByteString
b Ix m
i m a -> (a -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> Get m b -> ByteString -> Ix m -> m b
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet (a -> Get m b
f a
x) ByteString
b Ix m
i
  {-# INLINE (>>=) #-}
  >> :: forall a b. Get m a -> Get m b -> Get m b
(>>) = Get m a -> Get m b -> Get m b
forall a b. Get m a -> Get m b -> Get m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
  {-# INLINE (>>) #-}

instance (Monad m) => MonadFail (Get m) where
  fail :: forall a. [Char] -> Get m a
fail [Char]
s = GetExn -> Get m a
forall a e. Exception e => e -> a
throw (GetExn -> Get m a) -> GetExn -> Get m a
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
UserExn [Char]
s

instance MonadTrans Get where
  lift :: forall (m :: * -> *) a. Monad m => m a -> Get m a
lift m a
m = (ByteString -> Ix m -> m a) -> Get m a
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
_ Ix m
_ -> m a
m
  {-# INLINE lift #-}

remaining :: (PrimBase m) => Get m Int
remaining :: forall (m :: * -> *). PrimBase m => Get m Int
remaining = (ByteString -> Ix m -> m Int) -> Get m Int
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) -> ByteString -> Int -> Int
f ByteString
bs (Int -> Int) -> m Int -> m Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix
  where
    f :: ByteString -> Int -> Int
f ByteString
bs Int
i = ByteString -> Int
BS.length ByteString
bs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i
{-# INLINEABLE remaining #-}

getWord8 :: (PrimBase m) => Get m Word8
getWord8 :: forall (m :: * -> *). PrimBase m => Get m Word8
getWord8 = (ByteString -> Ix m -> m Word8) -> Get m Word8
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Word8) -> m Word8
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs ->
          ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i Word8 -> m () -> m Word8
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
      | Bool
otherwise -> GetExn -> m Word8
forall a e. Exception e => e -> a
throw (GetExn -> m Word8) -> GetExn -> m Word8
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getWord8"
{-# INLINE getWord8 #-}

getVarInt :: (Bits int, Num int, Ord int, PrimBase m) => Get m int
getVarInt :: forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt = (ByteString -> Ix m -> m int) -> Get m int
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) -> PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m int) -> m int
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ByteString -> PrimVar (PrimState m) Int -> Int -> m int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
ByteString -> PrimVar (PrimState m) Int -> Int -> m int
buildVarInt ByteString
bs PrimVar (PrimState m) Int
ix
{-# INLINEABLE getVarInt #-}

buildVarInt ::
  (Bits int, Num int, Ord int, PrimBase m) =>
  ByteString ->
  PrimVar (PrimState m) Int ->
  Int ->
  m int
buildVarInt :: forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
ByteString -> PrimVar (PrimState m) Int -> Int -> m int
buildVarInt ByteString
bs PrimVar (PrimState m) Int
ix Int
i0
  | Int
i0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz = Int -> int -> Int -> int -> m int
eat (Int
i0 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) int
0 Int
0 (int -> m int) -> int -> m int
forall a b. (a -> b) -> a -> b
$ Int -> int
grab Int
i0
  | Bool
otherwise = GetExn -> m int
forall a e. Exception e => e -> a
throw (GetExn -> m int) -> GetExn -> m int
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getVarInt"
  where
    sz :: Int
sz = ByteString -> Int
BS.length ByteString
bs
    grab :: Int -> int
grab Int
j = Word8 -> int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> int) -> Word8 -> int
forall a b. (a -> b) -> a -> b
$ ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
j

    eat :: Int -> int -> Int -> int -> m int
eat !Int
i !int
acc !Int
sh !int
m
      | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ int -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit int
m Int
7,
        int
acc <- int
acc int -> int -> int
forall a. Bits a => a -> a -> a
.|. (int
m int -> Int -> int
forall a. Bits a => a -> Int -> a
!<<. Int
sh) =
          int
acc int -> m () -> m int
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix Int
i
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz,
        int
acc <- int
acc int -> int -> int
forall a. Bits a => a -> a -> a
.|. (int -> Int -> int
forall a. Bits a => a -> Int -> a
clearBit int
m Int
7 int -> Int -> int
forall a. Bits a => a -> Int -> a
!<<. Int
sh) =
          Int -> int -> Int -> int -> m int
eat (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) int
acc (Int
sh Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7) (int -> m int) -> int -> m int
forall a b. (a -> b) -> a -> b
$ Int -> int
grab Int
i
      | Bool
otherwise =
          GetExn -> m int
forall a e. Exception e => e -> a
throw (GetExn -> m int) -> GetExn -> m int
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getVarInt"
{-# INLINEABLE buildVarInt #-}

getInt64be :: (PrimBase m) => Get m Int64
getInt64be :: forall (m :: * -> *). PrimBase m => Get m Int64
getInt64be = (ByteString -> Ix m -> m Int64) -> Get m Int64
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Int64) -> m Int64
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs -> ByteString -> Int -> Int64
forall {a}. (Bits a, Num a) => ByteString -> Int -> a
build ByteString
bs Int
i Int64 -> m () -> m Int64
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8)
      | Bool
otherwise -> GetExn -> m Int64
forall a e. Exception e => e -> a
throw (GetExn -> m Int64) -> GetExn -> m Int64
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getInt64be"
  where
    build :: ByteString -> Int -> a
build ByteString
bs !Int
i =
      (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
56)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
48)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
40)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
32)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
24)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
16)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
8)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7)))
{-# SPECIALIZE getInt64be :: Get IO Int64 #-}
{-# SPECIALIZE getInt64be :: Get (ST s) Int64 #-}

getWord16be :: (PrimBase m) => Get m Word16
getWord16be :: forall (m :: * -> *). PrimBase m => Get m Word16
getWord16be = (ByteString -> Ix m -> m Word16) -> Get m Word16
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Word16) -> m Word16
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs -> ByteString -> Int -> Word16
forall {a}. (Bits a, Num a) => ByteString -> Int -> a
build ByteString
bs Int
i Word16 -> m () -> m Word16
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
      | Bool
otherwise -> GetExn -> m Word16
forall a e. Exception e => e -> a
throw (GetExn -> m Word16) -> GetExn -> m Word16
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getWord16be"
  where
    build :: ByteString -> Int -> a
build ByteString
bs !Int
i =
      (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
8)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)))
{-# SPECIALIZE getWord16be :: Get IO Word16 #-}
{-# SPECIALIZE getWord16be :: Get (ST s) Word16 #-}

getWord32be :: (PrimBase m) => Get m Word32
getWord32be :: forall (m :: * -> *). PrimBase m => Get m Word32
getWord32be = (ByteString -> Ix m -> m Word32) -> Get m Word32
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Word32) -> m Word32
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs -> ByteString -> Int -> Word32
forall {a}. (Bits a, Num a) => ByteString -> Int -> a
build ByteString
bs Int
i Word32 -> m () -> m Word32
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)
      | Bool
otherwise -> GetExn -> m Word32
forall a e. Exception e => e -> a
throw (GetExn -> m Word32) -> GetExn -> m Word32
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getWord32be"
  where
    build :: ByteString -> Int -> a
build ByteString
bs !Int
i =
      (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
24)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
16)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
8)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)))
{-# SPECIALIZE getWord32be :: Get IO Word32 #-}
{-# SPECIALIZE getWord32be :: Get (ST s) Word32 #-}

getWord64be :: (PrimBase m) => Get m Word64
getWord64be :: forall (m :: * -> *). PrimBase m => Get m Word64
getWord64be = (ByteString -> Ix m -> m Word64) -> Get m Word64
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Word64) -> m Word64
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs -> ByteString -> Int -> Word64
forall {a}. (Bits a, Num a) => ByteString -> Int -> a
build ByteString
bs Int
i Word64 -> m () -> m Word64
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8)
      | Bool
otherwise -> GetExn -> m Word64
forall a e. Exception e => e -> a
throw (GetExn -> m Word64) -> GetExn -> m Word64
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getWord64be"
  where
    build :: ByteString -> Int -> a
build ByteString
bs !Int
i =
      (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
56)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
48)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
40)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
32)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
24)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
16)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
8)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7)))
{-# SPECIALIZE getWord64be :: Get IO Word64 #-}
{-# SPECIALIZE getWord64be :: Get (ST s) Word64 #-}

getWord64le :: (PrimBase m) => Get m Word64
getWord64le :: forall (m :: * -> *). PrimBase m => Get m Word64
getWord64le = (ByteString -> Ix m -> m Word64) -> Get m Word64
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) ->
  PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix m Int -> (Int -> m Word64) -> m Word64
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
i
      | Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs -> ByteString -> Int -> Word64
forall {a}. (Bits a, Num a) => ByteString -> Int -> a
build ByteString
bs Int
i Word64 -> m () -> m Word64
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8)
      | Bool
otherwise -> GetExn -> m Word64
forall a e. Exception e => e -> a
throw (GetExn -> m Word64) -> GetExn -> m Word64
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getWord64be"
  where
    build :: ByteString -> Int -> a
build ByteString
bs !Int
i =
      (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
56)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
48)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
40)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
32)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
24)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
16)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)) a -> Int -> a
forall a. Bits a => a -> Int -> a
!<<. Int
8)
        a -> a -> a
forall a. Bits a => a -> a -> a
.|. (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int -> Word8
BS.unsafeIndex ByteString
bs Int
i))
{-# SPECIALIZE getWord64le :: Get IO Word64 #-}
{-# SPECIALIZE getWord64le :: Get (ST s) Word64 #-}

getFloatbe :: (PrimBase m) => Get m Float
getFloatbe :: forall (m :: * -> *). PrimBase m => Get m Float
getFloatbe = Word32 -> Float
unisonWord32ToFloat (Word32 -> Float) -> Get m Word32 -> Get m Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get m Word32
forall (m :: * -> *). PrimBase m => Get m Word32
getWord32be
{-# INLINEABLE getFloatbe #-}

getDoublebe :: (PrimBase m) => Get m Double
getDoublebe :: forall (m :: * -> *). PrimBase m => Get m Double
getDoublebe = Word64 -> Double
unisonWord64ToDouble (Word64 -> Double) -> Get m Word64 -> Get m Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get m Word64
forall (m :: * -> *). PrimBase m => Get m Word64
getWord64be
{-# INLINEABLE getDoublebe #-}

getByteString :: (PrimBase m) => Int -> Get m ByteString
getByteString :: forall (m :: * -> *). PrimBase m => Int -> Get m ByteString
getByteString Int
n = (ByteString -> Ix m -> m ByteString) -> Get m ByteString
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs (Ix PrimVar (PrimState m) Int
ix) -> do
  Int
i <- PrimVar (PrimState m) Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> m a
readPrimVar PrimVar (PrimState m) Int
ix
  if Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= ByteString -> Int
BS.length ByteString
bs
    then Int -> ByteString -> ByteString
BS.unsafeTake Int
n (Int -> ByteString -> ByteString
BS.unsafeDrop Int
i ByteString
bs) ByteString -> m () -> m ByteString
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ PrimVar (PrimState m) Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimVar (PrimState m) a -> a -> m ()
writePrimVar PrimVar (PrimState m) Int
ix (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n)
    else GetExn -> m ByteString
forall a e. Exception e => e -> a
throw (GetExn -> m ByteString) -> GetExn -> m ByteString
forall a b. (a -> b) -> a -> b
$ [Char] -> GetExn
InsufficientBytes [Char]
"getBytes"
{-# INLINEABLE getByteString #-}

getList :: (PrimBase m) => Get m a -> Get m [a]
getList :: forall (m :: * -> *) a. PrimBase m => Get m a -> Get m [a]
getList Get m a
ga = Get m Int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt Get m Int -> (Int -> Get m [a]) -> Get m [a]
forall a b. Get m a -> (a -> Get m b) -> Get m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> Get m a -> Get m [a]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
`replicateM` Get m a
ga)
{-# INLINE getList #-}

-- Builds a result by repeated snoc in an efficient loop. Should only be
-- used when the snoc is efficient.
getAccumulating ::
  (PrimBase m) =>
  s ->
  (s -> a -> s) ->
  (s -> r) ->
  Get m a ->
  Get m r
getAccumulating :: forall (m :: * -> *) s a r.
PrimBase m =>
s -> (s -> a -> s) -> (s -> r) -> Get m a -> Get m r
getAccumulating s
nil s -> a -> s
snoc s -> r
finish = \Get m a
ga -> (ByteString -> Ix m -> m r) -> Get m r
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs Ix m
ix ->
  let loop :: s -> Int -> m r
loop !s
as (Int
n :: Int)
        | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = r -> m r
forall a (m :: * -> *). PrimMonad m => a -> m a
evalPrim (r -> m r) -> r -> m r
forall a b. (a -> b) -> a -> b
$ s -> r
finish s
as
        | Bool
otherwise = Get m a -> ByteString -> Ix m -> m a
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m a
ga ByteString
bs Ix m
ix m a -> (a -> m r) -> m r
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
a -> s -> Int -> m r
loop (s -> a -> s
snoc s
as a
a) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
   in Get m Int -> ByteString -> Ix m -> m Int
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m Int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt ByteString
bs Ix m
ix m Int -> (Int -> m r) -> m r
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> Int -> m r
loop s
nil
{-# INLINE getAccumulating #-}

getAccumulatingRevList ::
  (PrimBase m) =>
  ([a] -> r) ->
  Get m a ->
  Get m r
getAccumulatingRevList :: forall (m :: * -> *) a r.
PrimBase m =>
([a] -> r) -> Get m a -> Get m r
getAccumulatingRevList [a] -> r
finish = \Get m a
ga -> (ByteString -> Ix m -> m r) -> Get m r
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs Ix m
ix ->
  let loop :: [a] -> Int -> m r
loop [a]
as (Int
n :: Int)
        | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = r -> m r
forall a (m :: * -> *). PrimMonad m => a -> m a
evalPrim (r -> m r) -> r -> m r
forall a b. (a -> b) -> a -> b
$ [a] -> r
finish [a]
as
        | Bool
otherwise = Get m a -> ByteString -> Ix m -> m a
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m a
ga ByteString
bs Ix m
ix m a -> (a -> m r) -> m r
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
a -> [a] -> Int -> m r
loop (a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
as) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
   in Get m Int -> ByteString -> Ix m -> m Int
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m Int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt ByteString
bs Ix m
ix m Int -> (Int -> m r) -> m r
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [a] -> Int -> m r
loop []
{-# INLINE getAccumulatingRevList #-}

getSeq :: (PrimBase m) => Get m a -> Get m (Seq.Seq a)
getSeq :: forall (m :: * -> *) a. PrimBase m => Get m a -> Get m (Seq a)
getSeq Get m a
ga = Seq a
-> (Seq a -> a -> Seq a)
-> (Seq a -> Seq a)
-> Get m a
-> Get m (Seq a)
forall (m :: * -> *) s a r.
PrimBase m =>
s -> (s -> a -> s) -> (s -> r) -> Get m a -> Get m r
getAccumulating Seq a
forall a. Monoid a => a
mempty Seq a -> a -> Seq a
forall a. Seq a -> a -> Seq a
(Seq.|>) Seq a -> Seq a
forall a. a -> a
id Get m a
ga
{-# INLINEABLE getSeq #-}

getArray :: (PrimBase m) => Get m a -> Get m (Array a)
getArray :: forall (m :: * -> *) a. PrimBase m => Get m a -> Get m (Array a)
getArray Get m a
ga = (ByteString -> Ix m -> m (Array a)) -> Get m (Array a)
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs Ix m
ix -> do
  Int
sz <- Get m Int -> ByteString -> Ix m -> m Int
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m Int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt ByteString
bs Ix m
ix
  MutableArray (PrimState m) a
dst <- Int -> a -> m (MutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
sz ([Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"getArray: bad element")
  let fill :: Int -> m (Array a)
fill Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz = Get m a -> ByteString -> Ix m -> m a
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m a
ga ByteString
bs Ix m
ix m a -> (a -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
dst Int
i m () -> m (Array a) -> m (Array a)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m (Array a)
fill (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        | Bool
otherwise = MutableArray (PrimState m) a -> m (Array a)
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray MutableArray (PrimState m) a
dst
  Int -> m (Array a)
fill Int
0
{-# INLINE getArray #-}

getPrimArray :: (PrimBase m, Prim a) => Get m a -> Get m (PrimArray a)
getPrimArray :: forall (m :: * -> *) a.
(PrimBase m, Prim a) =>
Get m a -> Get m (PrimArray a)
getPrimArray Get m a
ga = (ByteString -> Ix m -> m (PrimArray a)) -> Get m (PrimArray a)
forall (m :: * -> *) a. (ByteString -> Ix m -> m a) -> Get m a
Get \ByteString
bs Ix m
ix -> do
  Int
sz <- Get m Int -> ByteString -> Ix m -> m Int
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m Int
forall int (m :: * -> *).
(Bits int, Num int, Ord int, PrimBase m) =>
Get m int
getVarInt ByteString
bs Ix m
ix
  MutablePrimArray (PrimState m) a
dst <- Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray Int
sz
  let fill :: Int -> m (PrimArray a)
fill Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz = Get m a -> ByteString -> Ix m -> m a
forall (m :: * -> *) a. Get m a -> ByteString -> Ix m -> m a
unGet Get m a
ga ByteString
bs Ix m
ix m a -> (a -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutablePrimArray (PrimState m) a -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> a -> m ()
writePrimArray MutablePrimArray (PrimState m) a
dst Int
i m () -> m (PrimArray a) -> m (PrimArray a)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m (PrimArray a)
fill (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        | Bool
otherwise = MutablePrimArray (PrimState m) a -> m (PrimArray a)
forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray MutablePrimArray (PrimState m) a
dst
  Int -> m (PrimArray a)
fill Int
0
{-# INLINE getPrimArray #-}