module Network.QUIC.Connection.Queue where

import UnliftIO.STM

import Network.QUIC.Connection.Types
import Network.QUIC.Stream
import Network.QUIC.Types

takeInput :: Connection -> IO Input
takeInput :: Connection -> IO Input
takeInput Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM a
readTQueue (Connection -> InputQ
inputQ Connection
conn)

putInput :: Connection -> Input -> IO ()
putInput :: Connection -> Input -> IO ()
putInput Connection
conn Input
inp = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> a -> STM ()
writeTQueue (Connection -> InputQ
inputQ Connection
conn) Input
inp

takeCrypto :: Connection -> IO Crypto
takeCrypto :: Connection -> IO Crypto
takeCrypto Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM a
readTQueue (Connection -> CryptoQ
cryptoQ Connection
conn)

putCrypto :: Connection -> Crypto -> IO ()
putCrypto :: Connection -> Crypto -> IO ()
putCrypto Connection
conn Crypto
inp = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> a -> STM ()
writeTQueue (Connection -> CryptoQ
cryptoQ Connection
conn) Crypto
inp

takeOutputSTM :: Connection -> STM Output
takeOutputSTM :: Connection -> STM Output
takeOutputSTM Connection
conn = forall a. TQueue a -> STM a
readTQueue (Connection -> OutputQ
outputQ Connection
conn)

tryTakeOutput :: Connection -> IO (Maybe Output)
tryTakeOutput :: Connection -> IO (Maybe Output)
tryTakeOutput Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM (Maybe a)
tryReadTQueue (Connection -> OutputQ
outputQ Connection
conn)

tryPeekOutput :: Connection -> IO (Maybe Output)
tryPeekOutput :: Connection -> IO (Maybe Output)
tryPeekOutput Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM (Maybe a)
tryPeekTQueue (Connection -> OutputQ
outputQ Connection
conn)

putOutput :: Connection -> Output -> IO ()
putOutput :: Connection -> Output -> IO ()
putOutput Connection
conn Output
out = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> a -> STM ()
writeTQueue (Connection -> OutputQ
outputQ Connection
conn) Output
out

----------------------------------------------------------------

takeSendStreamQ :: Connection -> IO TxStreamData
takeSendStreamQ :: Connection -> IO TxStreamData
takeSendStreamQ Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM a
readTQueue forall a b. (a -> b) -> a -> b
$ Shared -> SendStreamQ
sharedSendStreamQ forall a b. (a -> b) -> a -> b
$ Connection -> Shared
shared Connection
conn

takeSendStreamQSTM :: Connection -> STM TxStreamData
takeSendStreamQSTM :: Connection -> STM TxStreamData
takeSendStreamQSTM Connection
conn = forall a. TQueue a -> STM a
readTQueue forall a b. (a -> b) -> a -> b
$ Shared -> SendStreamQ
sharedSendStreamQ forall a b. (a -> b) -> a -> b
$ Connection -> Shared
shared Connection
conn

tryPeekSendStreamQ :: Connection -> IO (Maybe TxStreamData)
tryPeekSendStreamQ :: Connection -> IO (Maybe TxStreamData)
tryPeekSendStreamQ Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM (Maybe a)
tryPeekTQueue forall a b. (a -> b) -> a -> b
$ Shared -> SendStreamQ
sharedSendStreamQ forall a b. (a -> b) -> a -> b
$ Connection -> Shared
shared Connection
conn

putSendStreamQ :: Connection -> TxStreamData -> IO ()
putSendStreamQ :: Connection -> TxStreamData -> IO ()
putSendStreamQ Connection
conn TxStreamData
out = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> a -> STM ()
writeTQueue (Shared -> SendStreamQ
sharedSendStreamQ forall a b. (a -> b) -> a -> b
$ Connection -> Shared
shared Connection
conn) TxStreamData
out

----------------------------------------------------------------

readMigrationQ :: Connection -> IO ReceivedPacket
readMigrationQ :: Connection -> IO ReceivedPacket
readMigrationQ Connection
conn = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> STM a
readTQueue forall a b. (a -> b) -> a -> b
$ Connection -> MigrationQ
migrationQ Connection
conn

writeMigrationQ :: Connection -> ReceivedPacket -> IO ()
writeMigrationQ :: Connection -> ReceivedPacket -> IO ()
writeMigrationQ Connection
conn ReceivedPacket
x = forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TQueue a -> a -> STM ()
writeTQueue (Connection -> MigrationQ
migrationQ Connection
conn) ReceivedPacket
x