{-# LANGUAGE CPP #-}
{-# LANGUAGE PackageImports #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}

module Data.Primitive.PrimArray
  ( -- * Types
    PrimArray(..)
  , MutablePrimArray(..)
    -- * Allocation
  , newPrimArray
  , newPinnedPrimArray
  , newAlignedPinnedPrimArray
  , resizeMutablePrimArray
  , shrinkMutablePrimArray
    -- * Element Access
  , readPrimArray
  , writePrimArray
  , indexPrimArray
    -- * Freezing and Thawing
  , freezePrimArray
  , thawPrimArray
  , A.runPrimArray
  , unsafeFreezePrimArray
  , A.unsafeThawPrimArray
    -- * Block Operations
  , copyPrimArray
  , copyMutablePrimArray
  , copyPrimArrayToPtr
  , copyMutablePrimArrayToPtr
  , clonePrimArray
  , cloneMutablePrimArray
  , setPrimArray
    -- * Information
  , A.sameMutablePrimArray
  , A.getSizeofMutablePrimArray
  , A.sizeofMutablePrimArray
  , A.sizeofPrimArray
  , A.primArrayContents
  , A.mutablePrimArrayContents
  , A.isPrimArrayPinned
  , A.isMutablePrimArrayPinned
    -- * List Conversion
  , A.primArrayToList
  , A.primArrayFromList
  , A.primArrayFromListN
    -- * Folding
  , A.foldrPrimArray
  , A.foldrPrimArray'
  , A.foldlPrimArray
  , A.foldlPrimArray'
  , A.foldlPrimArrayM'
    -- * Effectful Folding
  , A.traversePrimArray_
  , A.itraversePrimArray_
    -- * Map/Create
  , A.emptyPrimArray
  , A.mapPrimArray
  , A.imapPrimArray
  , A.generatePrimArray
  , A.replicatePrimArray
  , A.filterPrimArray
  , A.mapMaybePrimArray
    -- * Effectful Map/Create

    -- ** Lazy Applicative
  , A.traversePrimArray
  , A.itraversePrimArray
  , A.generatePrimArrayA
  , A.replicatePrimArrayA
  , A.filterPrimArrayA
  , A.mapMaybePrimArrayA
    -- ** Strict Primitive Monadic
  , A.traversePrimArrayP
  , A.itraversePrimArrayP
  , A.generatePrimArrayP
  , A.replicatePrimArrayP
  , A.filterPrimArrayP
  , A.mapMaybePrimArrayP
  ) where

import Control.Monad.Primitive (PrimMonad, PrimState)
import Control.Exception (throw, ArrayException(..))
import Data.Primitive.Types (Prim, Ptr, sizeOf)
import Data.Word (Word8)
import "primitive" Data.Primitive.PrimArray (PrimArray, MutablePrimArray)
import qualified "primitive" Data.Primitive.PrimArray as A
import GHC.Stack
import qualified Data.List as L

check :: HasCallStack => String -> Bool -> a -> a
check :: String -> Bool -> a -> a
check String
_      Bool
True  a
x = a
x
check String
errMsg Bool
False a
_ = ArrayException -> a
forall a e. Exception e => e -> a
throw (String -> ArrayException
IndexOutOfBounds (String -> ArrayException) -> String -> ArrayException
forall a b. (a -> b) -> a -> b
$ String
"Data.Primitive.PrimArray." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
errMsg String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CallStack -> String
prettyCallStack CallStack
HasCallStack => CallStack
callStack)

newPrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray :: Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray Int
n =
    String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"newPrimArray: negative size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"newPrimArray: requested " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" elements of size " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
elemSz) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
elemSz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
A.newPrimArray Int
n
  where
  elemSz :: Int
elemSz = a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)

newPinnedPrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
newPinnedPrimArray :: Int -> m (MutablePrimArray (PrimState m) a)
newPinnedPrimArray Int
n =
    String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"newPinnedPrimArray: negative size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"newPinnedPrimArray: requested " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" elements of size " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
elemSz) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
elemSz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
A.newPinnedPrimArray Int
n
  where
  elemSz :: Int
elemSz = a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)

newAlignedPinnedPrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
newAlignedPinnedPrimArray :: Int -> m (MutablePrimArray (PrimState m) a)
newAlignedPinnedPrimArray Int
n =
    String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"newAlignedPinnedPrimArray: negative size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"newAlignedPinnedPrimArray: requested " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" elements of size " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
elemSz) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
elemSz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024)
  (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
A.newAlignedPinnedPrimArray Int
n
  where
  elemSz :: Int
elemSz = a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)

-- | After a call to 'resizeMutablePrimArray', the original reference to
-- the mutable array should not be used again. This cannot truly be enforced
-- except by linear types. To attempt to enforce this, we always make a
-- copy of the mutable primitive array and intentionally corrupt the original
-- of the original one. The strategy used here to corrupt the array is
-- simply to write @0xFF@ to every byte.
resizeMutablePrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a
  -> Int -- ^ new size
  -> m (MutablePrimArray (PrimState m) a)
resizeMutablePrimArray :: MutablePrimArray (PrimState m) a
-> Int -> m (MutablePrimArray (PrimState m) a)
resizeMutablePrimArray marr :: MutablePrimArray (PrimState m) a
marr@(A.MutablePrimArray MutableByteArray# (PrimState m)
x) Int
n = String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"resizeMutablePrimArray: negative size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0) (m (MutablePrimArray (PrimState m) a)
 -> m (MutablePrimArray (PrimState m) a))
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ do
  let sz :: Int
sz = MutablePrimArray (PrimState m) a -> Int
forall s a. Prim a => MutablePrimArray s a -> Int
A.sizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  MutablePrimArray (PrimState m) a
marr' <- MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
A.cloneMutablePrimArray MutablePrimArray (PrimState m) a
marr Int
0 Int
sz
  MutablePrimArray (PrimState m) Word8 -> Int -> Int -> Word8 -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
A.setPrimArray (MutableByteArray# (PrimState m)
-> MutablePrimArray (PrimState m) Word8
forall s a. MutableByteArray# s -> MutablePrimArray s a
A.MutablePrimArray MutableByteArray# (PrimState m)
x) Int
0 (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)) (Word8
0xFF :: Word8)
  MutablePrimArray (PrimState m) a
-> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return MutablePrimArray (PrimState m) a
marr'

freezePrimArray
  :: (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a -- ^ source
  -> Int                              -- ^ offset
  -> Int                              -- ^ length
  -> m (PrimArray a)
freezePrimArray :: MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
freezePrimArray MutablePrimArray (PrimState m) a
marr Int
s Int
l = String -> Bool -> m (PrimArray a) -> m (PrimArray a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"freezePrimArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= MutablePrimArray (PrimState m) a -> Int
forall s a. Prim a => MutablePrimArray s a -> Int
A.sizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr)
  (MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
A.freezePrimArray MutablePrimArray (PrimState m) a
marr Int
s Int
l)

thawPrimArray
  :: (HasCallStack, PrimMonad m, Prim a)
  => PrimArray a -- ^ source
  -> Int         -- ^ offset
  -> Int         -- ^ length
  -> m (MutablePrimArray (PrimState m) a)
thawPrimArray :: PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
thawPrimArray PrimArray a
arr Int
s Int
l = String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"thawPrimArray: index range of out bounds"
    (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
A.sizeofPrimArray PrimArray a
arr)
    (PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
A.thawPrimArray PrimArray a
arr Int
s Int
l)

-- | This corrupts the contents of the argument array by writing @0xFF@ to every byte.
unsafeFreezePrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a
  -> m (PrimArray a)
unsafeFreezePrimArray :: MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray marr :: MutablePrimArray (PrimState m) a
marr@(A.MutablePrimArray MutableByteArray# (PrimState m)
x) = do
  let sz :: Int
sz = MutablePrimArray (PrimState m) a -> Int
forall s a. Prim a => MutablePrimArray s a -> Int
A.sizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  PrimArray a
arr <- MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
A.freezePrimArray MutablePrimArray (PrimState m) a
marr Int
0 Int
sz
  MutablePrimArray (PrimState m) Word8 -> Int -> Int -> Word8 -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
A.setPrimArray (MutableByteArray# (PrimState m)
-> MutablePrimArray (PrimState m) Word8
forall s a. MutableByteArray# s -> MutablePrimArray s a
A.MutablePrimArray MutableByteArray# (PrimState m)
x) Int
0 (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)) (Word8
0xFF :: Word8)
  PrimArray a -> m (PrimArray a)
forall (m :: * -> *) a. Monad m => a -> m a
return PrimArray a
arr

shrinkMutablePrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a
  -> Int -- ^ new size
  -> m ()
shrinkMutablePrimArray :: MutablePrimArray (PrimState m) a -> Int -> m ()
shrinkMutablePrimArray MutablePrimArray (PrimState m) a
marr Int
n = do
  Int
old <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check String
"shrinkMutablePrimArray: illegal new size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
old) (MutablePrimArray (PrimState m) a -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> Int -> m ()
A.shrinkMutablePrimArray MutablePrimArray (PrimState m) a
marr Int
n)

readPrimArray :: (HasCallStack, Prim a, PrimMonad m) => MutablePrimArray (PrimState m) a -> Int -> m a
readPrimArray :: MutablePrimArray (PrimState m) a -> Int -> m a
readPrimArray MutablePrimArray (PrimState m) a
marr Int
i = do
  Int
siz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
siz
        , String
", index: "
        , Int -> String
forall a. Show a => a -> String
show Int
i
        , String
"]"
        ]
  String -> Bool -> m a -> m a
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"readPrimArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain) (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
siz) (MutablePrimArray (PrimState m) a -> Int -> m a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> m a
A.readPrimArray MutablePrimArray (PrimState m) a
marr Int
i)

writePrimArray :: (HasCallStack, Prim a, PrimMonad m)
  => MutablePrimArray (PrimState m) a -- ^ array
  -> Int -- ^ index
  -> a -- ^ element
  -> m ()
writePrimArray :: MutablePrimArray (PrimState m) a -> Int -> a -> m ()
writePrimArray MutablePrimArray (PrimState m) a
marr Int
i a
x = do
  Int
siz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
siz
        , String
", index: "
        , Int -> String
forall a. Show a => a -> String
show Int
i
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"writePrimArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain) (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
siz) (MutablePrimArray (PrimState m) a -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> a -> m ()
A.writePrimArray MutablePrimArray (PrimState m) a
marr Int
i a
x)

indexPrimArray :: forall a. Prim a => PrimArray a -> Int -> a
indexPrimArray :: PrimArray a -> Int -> a
indexPrimArray PrimArray a
arr Int
i =
  let sz :: Int
sz = PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
A.sizeofPrimArray PrimArray a
arr
      explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
sz
        , String
", index: "
        , Int -> String
forall a. Show a => a -> String
show Int
i
        , String
"]"
        ]
   in String -> Bool -> a -> a
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"indexPrimArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
        (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz)
        (PrimArray a -> Int -> a
forall a. Prim a => PrimArray a -> Int -> a
A.indexPrimArray PrimArray a
arr Int
i)

setPrimArray :: forall m a. (HasCallStack, Prim a, PrimMonad m)
  => MutablePrimArray (PrimState m) a -- ^ array to fill
  -> Int -- ^ offset into array
  -> Int -- ^ number of values to fill
  -> a -- ^ value to fill with
  -> m ()
setPrimArray :: MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
setPrimArray MutablePrimArray (PrimState m) a
dst Int
doff Int
sz a
x = do
  Int
arrSz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
dst
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
arrSz
        , String
", offset: "
        , Int -> String
forall a. Show a => a -> String
show Int
doff
        , String
", length: "
        , Int -> String
forall a. Show a => a -> String
show Int
sz
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"setPrimArray: index range of out bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
    (Int
doff Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
doff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
sz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
arrSz)
    (MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
A.setPrimArray MutablePrimArray (PrimState m) a
dst Int
doff Int
sz a
x)

copyPrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a -- ^ destination array
  -> Int -- ^ offset into destination array
  -> PrimArray a -- ^ source array
  -> Int -- ^ offset into source array
  -> Int -- ^ number of elements to copy
  -> m ()
copyPrimArray :: MutablePrimArray (PrimState m) a
-> Int -> PrimArray a -> Int -> Int -> m ()
copyPrimArray MutablePrimArray (PrimState m) a
marr Int
s1 PrimArray a
arr Int
s2 Int
l = do
  Int
dstSz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  let srcSz :: Int
srcSz = PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
A.sizeofPrimArray PrimArray a
arr
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[dst_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
dstSz
        , String
", dst_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s1
        , String
", src_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
srcSz
        , String
", src_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s2
        , String
", len: "
        , Int -> String
forall a. Show a => a -> String
show Int
l
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"copyPrimArray: index range of out bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
    (Int
s1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
dstSz Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
srcSz)
    (MutablePrimArray (PrimState m) a
-> Int -> PrimArray a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> PrimArray a -> Int -> Int -> m ()
A.copyPrimArray MutablePrimArray (PrimState m) a
marr Int
s1 PrimArray a
arr Int
s2 Int
l)

copyMutablePrimArray :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a -- ^ destination array
  -> Int -- ^ offset into destination array
  -> MutablePrimArray (PrimState m) a -- ^ source array
  -> Int -- ^ offset into source array
  -> Int -- ^ number of elements to copy
  -> m ()
copyMutablePrimArray :: MutablePrimArray (PrimState m) a
-> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
copyMutablePrimArray MutablePrimArray (PrimState m) a
marr1 Int
s1 MutablePrimArray (PrimState m) a
marr2 Int
s2 Int
l = do
  Int
dstSz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr1
  Int
srcSz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr2
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[dst_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
dstSz
        , String
", dst_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s1
        , String
", src_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
srcSz
        , String
", src_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s2
        , String
", len: "
        , Int -> String
forall a. Show a => a -> String
show Int
l
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"copyMutablePrimArray: index range of out bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
    (Int
s1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
dstSz Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
srcSz)
    (MutablePrimArray (PrimState m) a
-> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
A.copyMutablePrimArray MutablePrimArray (PrimState m) a
marr1 Int
s1 MutablePrimArray (PrimState m) a
marr2 Int
s2 Int
l)

copyPrimArrayToPtr :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => Ptr a -- ^ destination pointer
  -> PrimArray a -- ^ source array
  -> Int -- ^ offset into source array
  -> Int -- ^ number of elements to copy
  -> m ()
copyPrimArrayToPtr :: Ptr a -> PrimArray a -> Int -> Int -> m ()
copyPrimArrayToPtr Ptr a
ptr PrimArray a
arr Int
s Int
l = do
  let srcSz :: Int
srcSz = PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
A.sizeofPrimArray PrimArray a
arr
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[src_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
srcSz
        , String
", src_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s
        , String
", len: "
        , Int -> String
forall a. Show a => a -> String
show Int
l
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"copyPrimArrayToPtr: index range of out bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
    (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
srcSz)
    (Ptr a -> PrimArray a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Ptr a -> PrimArray a -> Int -> Int -> m ()
A.copyPrimArrayToPtr Ptr a
ptr PrimArray a
arr Int
s Int
l)

copyMutablePrimArrayToPtr :: forall m a. (HasCallStack, PrimMonad m, Prim a)
  => Ptr a -- ^ destination pointer
  -> MutablePrimArray (PrimState m) a -- ^ source array
  -> Int -- ^ offset into source array
  -> Int -- ^ number of elements to copy
  -> m ()
copyMutablePrimArrayToPtr :: Ptr a -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
copyMutablePrimArrayToPtr Ptr a
ptr MutablePrimArray (PrimState m) a
marr Int
s Int
l = do
  Int
srcSz <- MutablePrimArray (PrimState m) a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
A.getSizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr
  let explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[src_sz: "
        , Int -> String
forall a. Show a => a -> String
show Int
srcSz
        , String
", src_off: "
        , Int -> String
forall a. Show a => a -> String
show Int
s
        , String
", len: "
        , Int -> String
forall a. Show a => a -> String
show Int
l
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"copyMutablePrimArrayToPtr: index range of out bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
    (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
srcSz)
    (Ptr a -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Ptr a -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
A.copyMutablePrimArrayToPtr Ptr a
ptr MutablePrimArray (PrimState m) a
marr Int
s Int
l)

clonePrimArray :: (HasCallStack, Prim a)
  => PrimArray a -- ^ source array
  -> Int         -- ^ offset into source array
  -> Int         -- ^ number of elements to copy
  -> PrimArray a
clonePrimArray :: PrimArray a -> Int -> Int -> PrimArray a
clonePrimArray PrimArray a
arr Int
s Int
l = String -> Bool -> PrimArray a -> PrimArray a
forall a. HasCallStack => String -> Bool -> a -> a
check String
"clonePrimArray: index range of out bounds"
    (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
A.sizeofPrimArray PrimArray a
arr)
    (PrimArray a -> Int -> Int -> PrimArray a
forall a. Prim a => PrimArray a -> Int -> Int -> PrimArray a
A.clonePrimArray PrimArray a
arr Int
s Int
l)

cloneMutablePrimArray :: (HasCallStack, PrimMonad m, Prim a)
  => MutablePrimArray (PrimState m) a -- ^ source array
  -> Int                              -- ^ offset into source array
  -> Int                              -- ^ number of elements to copy
  -> m (MutablePrimArray (PrimState m) a)
cloneMutablePrimArray :: MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
cloneMutablePrimArray MutablePrimArray (PrimState m) a
marr Int
s Int
l = String
-> Bool
-> m (MutablePrimArray (PrimState m) a)
-> m (MutablePrimArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"cloneMutablePrimArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= MutablePrimArray (PrimState m) a -> Int
forall s a. Prim a => MutablePrimArray s a -> Int
A.sizeofMutablePrimArray MutablePrimArray (PrimState m) a
marr)
  (MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
A.cloneMutablePrimArray MutablePrimArray (PrimState m) a
marr Int
s Int
l)