packages feed

hoare-0.2.0.0: lib/Control/Concurrent/TBCQueue.hs

-- | A /closeable/, bounded STM queue.
module Control.Concurrent.TBCQueue(
    TBCQueue,
    newTBCQueue,
    newTBCQueueIO,
    readTBCQueue,
    drainTBCQueue,
    writeTBCQueue,
    overwriteTBCQueue,
    closeTBCQueue,
    isOpenTBCQueue,
    isClosedTBCQueue,
    isEmptyTBCQueue,
    isFullTBCQueue,
    lengthTBCQueue
) where

import Control.Concurrent.Channel.Overwrite
import Control.Concurrent.STM
import Control.Monad
import Numeric.Natural

data TBCQueue a = TBCQueue {
    q :: !(TBQueue a),
    open :: !(TVar Bool)
}

newTBCQueue :: Natural -> STM (TBCQueue a)
newTBCQueue n = TBCQueue <$> newTBQueue n <*> newTVar True

newTBCQueueIO :: Natural -> IO (TBCQueue a)
newTBCQueueIO = atomically . newTBCQueue

-- | Reads from the queue, blocking if empty,
-- and returning @Nothing@ once it is empty and closed.
readTBCQueue :: TBCQueue a -> STM (Maybe a)
readTBCQueue c = tryReadTBQueue c.q >>= \case
    Just v -> pure $ Just v
    Nothing -> do
        stillOpen <- readTVar c.open
        if stillOpen
            then retry
            else pure Nothing

drainTBCQueue :: TBCQueue a -> STM [a]
drainTBCQueue c = do
    f <- flushTBQueue c.q
    if null f
        then do
            stillOpen <- readTVar c.open
            if stillOpen
                then retry
                else pure []
        else pure f

-- | Writes the given value to the queue if it's still open, blocking if full.
--
-- Returns whether the queue is still open so producers know when consumers no longer care.
writeTBCQueue :: TBCQueue a -> a -> STM Bool
writeTBCQueue c !v = do
    stillOpen <- readTVar c.open
    when stillOpen $ writeTBQueue c.q v
    pure stillOpen

overwriteTBCQueue :: TBCQueue a -> a -> STM (OverwriteResult a)
overwriteTBCQueue c !v = do
    stillOpen <- readTVar c.open
    if stillOpen
        then do
            wasFull <- isFullTBQueue c.q
            if wasFull
                then do
                    o <- readTBQueue c.q
                    writeTBQueue c.q v
                    pure $ Overwrote o
                else do
                    writeTBQueue c.q v
                    pure Wrote
        else pure Closed

-- | Closes the queue so that future writes are no-ops and readers get @Nothing@
-- after all values currently inside have been read.
closeTBCQueue :: TBCQueue a -> STM ()
closeTBCQueue c = writeTVar c.open False

isOpenTBCQueue :: TBCQueue a -> STM Bool
isOpenTBCQueue c = readTVar c.open

isClosedTBCQueue :: TBCQueue a -> STM Bool
isClosedTBCQueue = fmap not . isOpenTBCQueue

isEmptyTBCQueue :: TBCQueue a -> STM Bool
isEmptyTBCQueue c = isEmptyTBQueue c.q

isFullTBCQueue :: TBCQueue a -> STM Bool
isFullTBCQueue c = isFullTBQueue c.q

-- | The number of items currently in the queue.
--
-- Be careful using this outside the current STM transaction as it is obviously racy.
lengthTBCQueue :: TBCQueue a -> STM Natural
lengthTBCQueue c = lengthTBQueue c.q