set of 9 colours proposed by bugq - attempting to avoid colours that are hard to distinguish
module Store(
ElemIndex(),
MStore(),
IStore(),
newStore,
addElem,
removeElem,
readElem,
writeElem,
modifyElem,
elemExists,
firstIndex,
indicesM,
withIStore,
withIStore2,
(!),
indices
) where
import qualified Data.Array.IArray as IA
import qualified Data.Array.IO as IOA
import qualified Data.IntSet as IntSet
import Data.IORef
import Control.Monad
newtype ElemIndex = ElemIndex Int
deriving (Eq, Show, Read, Ord)
newtype MStore e = MStore (IORef (IntSet.IntSet, IntSet.IntSet, IOA.IOArray Int e))
newtype IStore e = IStore (IntSet.IntSet, IA.Array Int e)
firstIndex :: ElemIndex
firstIndex = ElemIndex 0
-- MStore code
initialSize :: Int
initialSize = 16
growFunc :: Int -> Int
growFunc a = a * 3 `div` 2
truncFunc :: Int -> Int
truncFunc a | a > growFunc initialSize = (a `div` 2)
| otherwise = a
newStore :: IO (MStore e)
newStore = do
newar <- IOA.newArray_ (0, initialSize - 1)
new <- newIORef (IntSet.empty, IntSet.fromAscList [0..initialSize - 1], newar)
return (MStore new)
growStore :: MStore e -> IO ()
growStore (MStore ref) = do
(busyElems, freeElems, arr) <- readIORef ref
(_, m') <- IOA.getBounds arr
let newM' = growFunc (m' + 1) - 1
newArr <- IOA.newArray_ (0, newM')
sequence_ [IOA.readArray arr i >>= IOA.writeArray newArr i | i <- [0..m']]
writeIORef ref (busyElems, freeElems `IntSet.union` IntSet.fromAscList [m'+1..newM'], newArr)
growIfNeeded :: MStore e -> IO ()
growIfNeeded m@(MStore ref) = do
(_, freeElems, _) <- readIORef ref
when (IntSet.null freeElems) $ growStore m
truncateIfNeeded :: MStore e -> IO ()
truncateIfNeeded (MStore ref) = do
(busyElems, _, arr) <- readIORef ref
(_, m') <- IOA.getBounds arr
let newM' = truncFunc (m' + 1) - 1
when (newM' < m' && (not $ IntSet.null busyElems) && IntSet.findMax busyElems <= newM') $ do
newArr <- IOA.newArray_ (0, newM')
sequence_ [IOA.readArray arr i >>= IOA.writeArray newArr i | i <- IntSet.toList busyElems]
writeIORef ref (busyElems, IntSet.fromAscList [0..newM'] `IntSet.difference` busyElems, newArr)
addElem :: MStore e -> e -> IO ElemIndex
addElem m@(MStore ref) element = do
growIfNeeded m
(busyElems, freeElems, arr) <- readIORef ref
let (n, freeElems') = IntSet.deleteFindMin freeElems
IOA.writeArray arr n element
writeIORef ref (IntSet.insert n busyElems, freeElems', arr)
return $ ElemIndex n
removeElem :: MStore e -> ElemIndex -> IO ()
removeElem m@(MStore ref) (ElemIndex n) = do
(busyElems, freeElems, arr) <- readIORef ref
IOA.writeArray arr n (error $ "Store: no element " ++ show n)
writeIORef ref (IntSet.delete n busyElems, IntSet.insert n freeElems, arr)
truncateIfNeeded m
readElem :: MStore e -> ElemIndex -> IO e
readElem (MStore ref) (ElemIndex n) = readIORef ref >>= \(_, _, arr) -> IOA.readArray arr n
writeElem :: MStore e -> ElemIndex -> e -> IO ()
writeElem (MStore ref) (ElemIndex n) el = readIORef ref >>= \(_, _, arr) -> IOA.writeArray arr n el
modifyElem :: MStore e -> (e -> e) -> ElemIndex -> IO ()
modifyElem (MStore ref) f (ElemIndex n) = do
(_, _, arr) <- readIORef ref
IOA.readArray arr n >>= IOA.writeArray arr n . f
elemExists :: MStore e -> ElemIndex -> IO Bool
elemExists (MStore ref) (ElemIndex n) = do
(_, free, _) <- readIORef ref
return $ n `IntSet.notMember` free
indicesM :: MStore e -> IO [ElemIndex]
indicesM (MStore ref) = do
(busy, _, _) <- readIORef ref
return $ map ElemIndex $ IntSet.toList busy
-- A way to see MStore elements in pure code via IStore
m2i :: MStore e -> IO (IStore e)
m2i (MStore ref) = do
(a, _, c') <- readIORef ref
c <- IOA.unsafeFreeze c'
return $ IStore (a, c)
i2m :: MStore e -> IStore e -> IO ()
i2m (MStore ref) (IStore (_, arr)) = do
(b, e, _) <- readIORef ref
a <- IOA.unsafeThaw arr
writeIORef ref (b, e, a)
withIStore :: MStore e -> (IStore e -> a) -> IO a
withIStore m f = do
i <- m2i m
let res = f i
res `seq` i2m m i
return res
withIStore2 :: MStore e1 -> MStore e2 -> (IStore e1 -> IStore e2 -> a) -> IO a
withIStore2 m1 m2 f = do
i1 <- m2i m1
i2 <- m2i m2
let res = f i1 i2
res `seq` i2m m1 i1
i2m m2 i2
return res
-- IStore code
(!) :: IStore e -> ElemIndex -> e
(!) (IStore (_, arr)) (ElemIndex i) = (IA.!) arr i
indices :: IStore e -> [ElemIndex]
indices (IStore (busy, _)) = map ElemIndex $ IntSet.toList busy