module Data.Cache.LRU.IO.Internal where
import Prelude hiding ( lookup )
import Control.Applicative ( (<$>) )
import Control.Concurrent.MVar ( MVar )
import qualified Control.Concurrent.MVar as MV
import Data.Cache.LRU ( LRU )
import qualified Data.Cache.LRU as LRU
newtype AtomicLRU key val = C (MVar (LRU key val))
newAtomicLRU :: Ord key => Int
-> IO (AtomicLRU key val)
newAtomicLRU = fmap C . MV.newMVar . LRU.newLRU
fromList :: Ord key => Int
-> [(key, val)] -> IO (AtomicLRU key val)
fromList s l = fmap C . MV.newMVar $ LRU.fromList s l
toList :: Ord key => AtomicLRU key val -> IO [(key, val)]
toList (C mvar) = LRU.toList <$> MV.readMVar mvar
maxSize :: AtomicLRU key val -> IO Int
maxSize (C mvar) = LRU.maxSize <$> MV.readMVar mvar
insert :: Ord key => key -> val -> AtomicLRU key val -> IO ()
insert key val (C mvar) = modifyMVar_' mvar $ return . LRU.insert key val
lookup :: Ord key => key -> AtomicLRU key val -> IO (Maybe val)
lookup key (C mvar) = modifyMVar' mvar $ return . LRU.lookup key
delete :: Ord key => key -> AtomicLRU key val -> IO Bool
delete key (C mvar) = modifyMVar' mvar $ return . LRU.delete key
size :: AtomicLRU key val -> IO Int
size (C mvar) = LRU.size <$> MV.readMVar mvar
modifyMVar_' :: MVar a -> (a -> IO a) -> IO ()
modifyMVar_' mvar f = do
x <- MV.takeMVar mvar
x' <- f x
MV.putMVar mvar $! x'
modifyMVar' :: MVar a -> (a -> IO (a, b)) -> IO b
modifyMVar' mvar f = do
x <- MV.takeMVar mvar
(x', result) <- f x
MV.putMVar mvar $! x'
return result