Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.GLib.Structs.AsyncQueue

Contents

Exported types
Methods

Description

The GAsyncQueue struct is an opaque data structure which represents an asynchronous queue. It should only be accessed through the g_async_queue_* functions.

Synopsis

newtype AsyncQueue = AsyncQueue (ManagedPtr AsyncQueue)
noAsyncQueue :: Maybe AsyncQueue
asyncQueueLength :: (HasCallStack, MonadIO m) => AsyncQueue -> m Int32
asyncQueueLengthUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> m Int32
asyncQueueLock :: (HasCallStack, MonadIO m) => AsyncQueue -> m ()
asyncQueuePop :: (HasCallStack, MonadIO m) => AsyncQueue -> m (Ptr ())
asyncQueuePopUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> m (Ptr ())
asyncQueuePush :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m ()
asyncQueuePushFront :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m ()
asyncQueuePushFrontUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m ()
asyncQueuePushUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m ()
asyncQueueRefUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> m ()
asyncQueueRemove :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m Bool
asyncQueueRemoveUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> Ptr () -> m Bool
asyncQueueTimedPop :: (HasCallStack, MonadIO m) => AsyncQueue -> TimeVal -> m (Ptr ())
asyncQueueTimedPopUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> TimeVal -> m (Ptr ())
asyncQueueTimeoutPop :: (HasCallStack, MonadIO m) => AsyncQueue -> Word64 -> m (Ptr ())
asyncQueueTimeoutPopUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> Word64 -> m (Ptr ())
asyncQueueTryPop :: (HasCallStack, MonadIO m) => AsyncQueue -> m (Ptr ())
asyncQueueTryPopUnlocked :: (HasCallStack, MonadIO m) => AsyncQueue -> m (Ptr ())
asyncQueueUnlock :: (HasCallStack, MonadIO m) => AsyncQueue -> m ()
asyncQueueUnref :: (HasCallStack, MonadIO m) => AsyncQueue -> m ()
asyncQueueUnrefAndUnlock :: (HasCallStack, MonadIO m) => AsyncQueue -> m ()

Exported types

newtype AsyncQueue Source #

Memory-managed wrapper type.

Constructors

AsyncQueue (ManagedPtr AsyncQueue)

Instances

WrappedPtr AsyncQueue Source #
Instance details Defined in GI.GLib.Structs.AsyncQueue Methods wrappedPtrCalloc :: IO (Ptr AsyncQueue) # wrappedPtrCopy :: AsyncQueue -> IO AsyncQueue # wrappedPtrFree :: Maybe (FunPtr (Ptr AsyncQueue -> IO ())) #

noAsyncQueue :: Maybe AsyncQueue Source #

A convenience alias for Nothing :: Maybe AsyncQueue.

Methods

length

asyncQueueLength Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`.
-> m Int32	Returns: the length of the `queue`

Returns the length of the queue.

Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling.

lengthUnlocked

asyncQueueLengthUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m Int32	Returns: the length of the `queue`.

Returns the length of the queue.

Actually this function returns the number of data items in the queue minus the number of waiting threads, so a negative value means waiting threads, and a positive value means available entries in the queue. A return value of 0 could mean n entries in the queue and n threads waiting. This can happen due to locking of the queue or due to scheduling.

This function must be called while holding the queue's lock.

lock

asyncQueueLock Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m ()

Acquires the queue's lock. If another thread is already holding the lock, this call will block until the lock becomes available.

Call asyncQueueUnlock to drop the lock again.

While holding the lock, you can only call the g_async_queue_*_unlocked() functions on queue. Otherwise, deadlock may occur.

pop

asyncQueuePop Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m (Ptr ())	Returns: data from the queue

Pops data from the queue. If queue is empty, this function blocks until data becomes available.

popUnlocked

asyncQueuePopUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m (Ptr ())	Returns: data from the queue.

Pops data from the queue. If queue is empty, this function blocks until data becomes available.

This function must be called while holding the queue's lock.

push

asyncQueuePush Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`data`: `data` to push into the `queue`
-> m ()

Pushes the data into the queue. data must not be Nothing.

pushFront

asyncQueuePushFront Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`item`: data to push into the `queue`
-> m ()

Pushes the item into the queue. item must not be Nothing. In contrast to asyncQueuePush, this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue.

Since: 2.46

pushFrontUnlocked

asyncQueuePushFrontUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`item`: data to push into the `queue`
-> m ()

Pushes the item into the queue. item must not be Nothing. In contrast to asyncQueuePushUnlocked, this function pushes the new item ahead of the items already in the queue, so that it will be the next one to be popped off the queue.

This function must be called while holding the queue's lock.

Since: 2.46

pushUnlocked

asyncQueuePushUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`data`: `data` to push into the `queue`
-> m ()

Pushes the data into the queue. data must not be Nothing.

This function must be called while holding the queue's lock.

refUnlocked

asyncQueueRefUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m ()

Deprecated: (Since version 2.8)Reference counting is done atomically.so g_async_queue_ref() can be used regardless of the queue'slock.

Increases the reference count of the asynchronous queue by 1.

remove

asyncQueueRemove Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`item`: the data to remove from the `queue`
-> m Bool	Returns: `True` if the item was removed

Remove an item from the queue.

Since: 2.46

removeUnlocked

asyncQueueRemoveUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Ptr ()	`item`: the data to remove from the `queue`
-> m Bool	Returns: `True` if the item was removed

Remove an item from the queue.

This function must be called while holding the queue's lock.

Since: 2.46

timedPop

asyncQueueTimedPop Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> TimeVal	`endTime`: a `TimeVal`, determining the final time
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is received before `endTime`.

Deprecated: use asyncQueueTimeoutPop.

Pops data from the queue. If the queue is empty, blocks until endTime or until data becomes available.

If no data is received before endTime, Nothing is returned.

To easily calculate endTime, a combination of getCurrentTime and timeValAdd can be used.

timedPopUnlocked

asyncQueueTimedPopUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> TimeVal	`endTime`: a `TimeVal`, determining the final time
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is received before `endTime`.

Deprecated: use asyncQueueTimeoutPopUnlocked.

Pops data from the queue. If the queue is empty, blocks until endTime or until data becomes available.

If no data is received before endTime, Nothing is returned.

To easily calculate endTime, a combination of getCurrentTime and timeValAdd can be used.

This function must be called while holding the queue's lock.

timeoutPop

asyncQueueTimeoutPop Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Word64	`timeout`: the number of microseconds to wait
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is received before the timeout.

Pops data from the queue. If the queue is empty, blocks for timeout microseconds, or until data becomes available.

If no data is received before the timeout, Nothing is returned.

timeoutPopUnlocked

asyncQueueTimeoutPopUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> Word64	`timeout`: the number of microseconds to wait
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is received before the timeout.

Pops data from the queue. If the queue is empty, blocks for timeout microseconds, or until data becomes available.

If no data is received before the timeout, Nothing is returned.

This function must be called while holding the queue's lock.

tryPop

asyncQueueTryPop Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is available immediately.

Tries to pop data from the queue. If no data is available, Nothing is returned.

tryPopUnlocked

asyncQueueTryPopUnlocked Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m (Ptr ())	Returns: data from the queue or `Nothing`, when no data is available immediately.

Tries to pop data from the queue. If no data is available, Nothing is returned.

This function must be called while holding the queue's lock.

unlock

asyncQueueUnlock Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m ()

Releases the queue's lock.

Calling this function when you have not acquired the with asyncQueueLock leads to undefined behaviour.

unref

asyncQueueUnref Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`.
-> m ()

Decreases the reference count of the asynchronous queue by 1.

If the reference count went to 0, the queue will be destroyed and the memory allocated will be freed. So you are not allowed to use the queue afterwards, as it might have disappeared. You do not need to hold the lock to call this function.

unrefAndUnlock

asyncQueueUnrefAndUnlock Source #

Arguments

:: (HasCallStack, MonadIO m)
=> AsyncQueue	`queue`: a `AsyncQueue`
-> m ()

Deprecated: (Since version 2.8)Reference counting is done atomically.so asyncQueueUnref can be used regardless of the queue'slock.

Decreases the reference count of the asynchronous queue by 1 and releases the lock. This function must be called while holding the queue's lock. If the reference count went to 0, the queue will be destroyed and the memory allocated will be freed.