{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
-- |
-- Module      : Data.Prim.Memory.Ptr
-- Copyright   : (c) Alexey Kuleshevich 2020
-- License     : BSD3
-- Maintainer  : Alexey Kuleshevich <alexey@kuleshevi.ch>
-- Stability   : experimental
-- Portability : non-portable
--
module Data.Prim.Memory.Ptr
  ( module Foreign.Prim.Ptr

  , copyPtrToMBytes
  , movePtrToMBytes
  , copyBytesToPtr
  , copyMBytesToPtr
  , moveMBytesToPtr
  , copyByteOffPtrToMBytes
  , moveByteOffPtrToMBytes
  , copyByteOffBytesToPtr
  , copyByteOffMBytesToPtr
  , moveByteOffMBytesToPtr
  , compareByteOffBytesToPtr
  , compareByteOffPtrToBytes
  , module Data.Prim
  ) where


import Control.Prim.Monad
import Control.Prim.Monad.Unsafe
import Data.Prim
import Data.Prim.Memory.Bytes.Internal (Bytes(..), MBytes(..))
import Data.Prim.Class
import Foreign.Prim
import Foreign.Prim.Ptr



copyPtrToMBytes ::
     (MonadPrim s m, Prim e) => Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
copyPtrToMBytes :: Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
copyPtrToMBytes Ptr e
src Off e
srcOff MBytes p s
dst Off e
dstOff =
  Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
forall s (m :: * -> *) e (p :: Pinned).
(MonadPrim s m, Prim e) =>
Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
copyByteOffPtrToMBytes Ptr e
src (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
srcOff) MBytes p s
dst (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
dstOff)
{-# INLINE copyPtrToMBytes #-}



copyByteOffPtrToMBytes ::
     (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
copyByteOffPtrToMBytes :: Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
copyByteOffPtrToMBytes (Ptr Addr#
srcAddr#) (Off (I# Int#
srcOff#)) (MBytes MutableByteArray# s
dst#) (Off (I# Int#
dstOff#)) Count e
c =
  (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ ((State# s -> State# s) -> m ()) -> (State# s -> State# s) -> m ()
forall a b. (a -> b) -> a -> b
$ Addr#
-> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
Addr#
-> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyAddrToByteArray# (Addr#
srcAddr# Addr# -> Int# -> Addr#
`plusAddr#` Int#
srcOff#) MutableByteArray# s
dst# Int#
dstOff# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c)
{-# INLINE copyByteOffPtrToMBytes #-}


copyBytesToPtr :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyBytesToPtr :: Bytes p -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyBytesToPtr Bytes p
src Off e
srcOff Ptr e
dst Off e
dstOff =
  Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
forall s (m :: * -> *) e (p :: Pinned).
(MonadPrim s m, Prim e) =>
Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffBytesToPtr Bytes p
src (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
srcOff) Ptr e
dst (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
dstOff)
{-# INLINE copyBytesToPtr #-}


copyByteOffBytesToPtr ::
     (MonadPrim s m, Prim e)
  => Bytes p
  -> Off Word8
  -> Ptr e
  -> Off Word8
  -> Count e
  -> m ()
copyByteOffBytesToPtr :: Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffBytesToPtr (Bytes ByteArray#
src#) (Off (I# Int#
srcOff#)) (Ptr Addr#
dstAddr#) (Off (I# Int#
dstOff#)) Count e
c =
  (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ ((State# s -> State# s) -> m ()) -> (State# s -> State# s) -> m ()
forall a b. (a -> b) -> a -> b
$
  ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s
forall d.
ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
copyByteArrayToAddr#
    ByteArray#
src#
    Int#
srcOff#
    (Addr#
dstAddr# Addr# -> Int# -> Addr#
`plusAddr#` Int#
dstOff#)
    (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c)
{-# INLINE copyByteOffBytesToPtr #-}


copyMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyMBytesToPtr :: MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyMBytesToPtr MBytes p s
src Off e
srcOff Ptr e
dst Off e
dstOff =
  MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
forall s (m :: * -> *) e (p :: Pinned).
(MonadPrim s m, Prim e) =>
MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffMBytesToPtr MBytes p s
src (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
srcOff) Ptr e
dst (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
dstOff)
{-# INLINE copyMBytesToPtr #-}


copyByteOffMBytesToPtr ::
     (MonadPrim s m, Prim e)
  => MBytes p s
  -> Off Word8
  -> Ptr e
  -> Off Word8
  -> Count e
  -> m ()
copyByteOffMBytesToPtr :: MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffMBytesToPtr (MBytes MutableByteArray# s
src#) (Off (I# Int#
srcOff#)) (Ptr Addr#
dstAddr#) (Off (I# Int#
dstOff#)) Count e
c =
  (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ ((State# s -> State# s) -> m ()) -> (State# s -> State# s) -> m ()
forall a b. (a -> b) -> a -> b
$
  MutableByteArray# s
-> Int# -> Addr# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d
-> Int# -> Addr# -> Int# -> State# d -> State# d
copyMutableByteArrayToAddr#
    MutableByteArray# s
src#
    Int#
srcOff#
    (Addr#
dstAddr# Addr# -> Int# -> Addr#
`plusAddr#` Int#
dstOff#)
    (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c)
{-# INLINE copyByteOffMBytesToPtr #-}


movePtrToMBytes :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
movePtrToMBytes :: Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
movePtrToMBytes Ptr e
src Off e
srcOff MBytes p s
dst Off e
dstOff =
  Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
forall s (m :: * -> *) e (p :: Pinned).
(MonadPrim s m, Prim e) =>
Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
moveByteOffPtrToMBytes Ptr e
src (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
srcOff) MBytes p s
dst (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
dstOff)
{-# INLINE movePtrToMBytes #-}

moveByteOffPtrToMBytes ::
     (MonadPrim s m, Prim e)
  => Ptr e
  -> Off Word8
  -> MBytes p s
  -> Off Word8
  -> Count e
  -> m ()
moveByteOffPtrToMBytes :: Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
moveByteOffPtrToMBytes (Ptr Addr#
srcAddr#) (Off (I# Int#
srcOff#)) (MBytes MutableByteArray# s
dst#) (Off (I# Int#
dstOff#)) Count e
c =
  IO () -> m ()
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Addr# -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()
forall s.
Addr# -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()
memmoveMutableByteArrayFromAddr# Addr#
srcAddr# Int#
srcOff# MutableByteArray# s
dst# Int#
dstOff# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c)
{-# INLINE moveByteOffPtrToMBytes #-}

moveMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
moveMBytesToPtr :: MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
moveMBytesToPtr MBytes p s
src Off e
srcOff Ptr e
dst Off e
dstOff =
  MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
forall s (m :: * -> *) e (p :: Pinned).
(MonadPrim s m, Prim e) =>
MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
moveByteOffMBytesToPtr MBytes p s
src (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
srcOff) Ptr e
dst (Off e -> Off Word8
forall e. Prim e => Off e -> Off Word8
toByteOff Off e
dstOff)
{-# INLINE moveMBytesToPtr #-}


moveByteOffMBytesToPtr ::
  (MonadPrim s m, Prim e) => MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
moveByteOffMBytesToPtr :: MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
moveByteOffMBytesToPtr (MBytes MutableByteArray# s
src#) (Off (I# Int#
srcOff#)) (Ptr Addr#
dstAddr#) (Off (I# Int#
dstOff#)) Count e
c =
  IO () -> m ()
forall s (m :: * -> *) a. MonadPrim s m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  MutableByteArray# s -> Int# -> Addr# -> Int# -> Int# -> IO ()
forall s.
MutableByteArray# s -> Int# -> Addr# -> Int# -> Int# -> IO ()
memmoveMutableByteArrayToAddr# MutableByteArray# s
src# Int#
srcOff# Addr#
dstAddr# Int#
dstOff# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c)
{-# INLINE moveByteOffMBytesToPtr #-}


compareByteOffBytesToPtr ::
     Prim e => Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> Ordering
compareByteOffBytesToPtr :: Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> Ordering
compareByteOffBytesToPtr (Bytes ByteArray#
b#) (Off (I# Int#
off1#)) (Ptr Addr#
addr#) (Off (I# Int#
off2#)) Count e
c =
  Int# -> Ordering
toOrdering# (ByteArray# -> Int# -> Addr# -> Int# -> Int# -> Int#
memcmpByteArrayAddr# ByteArray#
b# Int#
off1# Addr#
addr# Int#
off2# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c))
{-# INLINE compareByteOffBytesToPtr #-}

compareByteOffPtrToBytes ::
     Prim e => Ptr e -> Off Word8 -> Bytes p -> Off Word8 -> Count e -> Ordering
compareByteOffPtrToBytes :: Ptr e -> Off Word8 -> Bytes p -> Off Word8 -> Count e -> Ordering
compareByteOffPtrToBytes (Ptr Addr#
addr#) (Off (I# Int#
off1#)) (Bytes ByteArray#
b#) (Off (I# Int#
off2#)) Count e
c =
  Int# -> Ordering
toOrdering# (Addr# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
memcmpAddrByteArray# Addr#
addr# Int#
off1# ByteArray#
b# Int#
off2# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# Count e
c))
{-# INLINE compareByteOffPtrToBytes #-}