module Ptr.ByteString where

import qualified Data.ByteString.Internal as B
import qualified Ptr.Parse as C
import qualified Ptr.Peek as D
import qualified Ptr.Poking as A
import Ptr.Prelude

{-# INLINE poking #-}
poking :: A.Poking -> B.ByteString
poking :: Poking -> ByteString
poking (A.Poking Int
size Ptr Word8 -> IO ()
population) =
  Int -> (Ptr Word8 -> IO ()) -> ByteString
B.unsafeCreate Int
size Ptr Word8 -> IO ()
population

{-# INLINE parse #-}
parse :: B.ByteString -> C.Parse result -> (Int -> result) -> (Text -> result) -> result
parse :: forall result.
ByteString
-> Parse result -> (Int -> result) -> (Text -> result) -> result
parse (B.PS ForeignPtr Word8
fp Int
offset Int
length) (C.Parse Int
-> Ptr Word8
-> forall result.
   (Int -> IO result)
   -> (Text -> IO result)
   -> (result -> Int -> Ptr Word8 -> IO result)
   -> IO result
parseIO) Int -> result
eoi Text -> result
error =
  {-# SCC "parse" #-}
  forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
ptr ->
      Int
-> Ptr Word8
-> forall result.
   (Int -> IO result)
   -> (Text -> IO result)
   -> (result -> Int -> Ptr Word8 -> IO result)
   -> IO result
parseIO Int
length (forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr Word8
ptr Int
offset) (forall (m :: * -> *) a. Monad m => a -> m a
return forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Int -> result
eoi) (forall (m :: * -> *) a. Monad m => a -> m a
return forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Text -> result
error) (\result
result Int
_ Ptr Word8
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return result
result)

{-# INLINE peek #-}
peek :: B.ByteString -> D.Peek result -> Maybe result
peek :: forall result. ByteString -> Peek result -> Maybe result
peek (B.PS ForeignPtr Word8
fp Int
offset Int
length) (D.Peek Int
amount Ptr Word8 -> IO result
io) =
  {-# SCC "peek" #-}
  if Int
amount forall a. Ord a => a -> a -> Bool
<= Int
length
    then forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
      forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
        forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Word8
fp forall a b. (a -> b) -> a -> b
$ \Ptr Word8
ptr ->
          Ptr Word8 -> IO result
io (forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr Word8
ptr Int
offset)
    else forall a. Maybe a
Nothing