module Data.Vector.Primitive.Mutable (
MVector(..), IOVector, STVector, Prim,
length, overlaps, slice, new, newWith, read, write, swap,
clear, set, copy, grow,
unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
unsafeCopy, unsafeGrow
) where
import qualified Data.Vector.Generic.Mutable as G
import Data.Primitive.ByteArray
import Data.Primitive ( Prim, sizeOf )
import Control.Monad.Primitive
import Control.Monad ( liftM )
import Prelude hiding( length, read )
import Data.Typeable ( Typeable )
#include "vector.h"
data MVector s a = MVector !Int
!Int
!(MutableByteArray s)
deriving ( Typeable )
type IOVector = MVector RealWorld
type STVector s = MVector s
instance Prim a => G.MVector MVector a where
basicLength (MVector _ n _) = n
basicUnsafeSlice j m (MVector i n arr)
= MVector (i+j) m arr
basicOverlaps (MVector i m arr1) (MVector j n arr2)
= sameMutableByteArray arr1 arr2
&& (between i j (j+n) || between j i (i+m))
where
between x y z = x >= y && x < z
basicUnsafeNew n = MVector 0 n
`liftM` newByteArray (n * sizeOf (undefined :: a))
basicUnsafeRead (MVector i n arr) j = readByteArray arr (i+j)
basicUnsafeWrite (MVector i n arr) j x = writeByteArray arr (i+j) x
basicUnsafeCopy (MVector i n dst) (MVector j _ src)
= memcpyByteArray dst (i * sz) src (j * sz) (n * sz)
where
sz = sizeOf (undefined :: a)
unsafeSlice :: Prim a => Int
-> Int
-> MVector s a
-> MVector s a
unsafeSlice = G.unsafeSlice
unsafeNew :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
unsafeNew = G.unsafeNew
unsafeNewWith :: (PrimMonad m, Prim a)
=> Int -> a -> m (MVector (PrimState m) a)
unsafeNewWith = G.unsafeNewWith
unsafeRead :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
unsafeRead = G.unsafeRead
unsafeWrite :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> Int -> a -> m ()
unsafeWrite = G.unsafeWrite
unsafeSwap :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = G.unsafeSwap
unsafeCopy :: (PrimMonad m, Prim a) => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
unsafeCopy = G.unsafeCopy
unsafeGrow :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
unsafeGrow = G.unsafeGrow
length :: Prim a => MVector s a -> Int
length = G.length
overlaps :: Prim a => MVector s a -> MVector s a -> Bool
overlaps = G.overlaps
slice :: Prim a => Int -> Int -> MVector s a -> MVector s a
slice = G.slice
new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
new = G.new
newWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
newWith = G.newWith
read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
read = G.read
write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
write = G.write
swap :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> Int -> Int -> m ()
swap = G.swap
clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m ()
clear = G.clear
set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m ()
set = G.set
copy :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
copy = G.copy
grow :: (PrimMonad m, Prim a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
grow = G.grow