gi-glib-2.0.17: GLib bindings

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.RecMutex

Contents

- Exported types
- Methods
  - clear
  - init
  - lock
  - trylock
  - unlock

Description

The GRecMutex struct is an opaque data structure to represent a recursive mutex. It is similar to a `Mutex` with the difference that it is possible to lock a GRecMutex multiple times in the same thread without deadlock. When doing so, care has to be taken to unlock the recursive mutex as often as it has been locked.

If a `RecMutex` is allocated in static storage then it can be used without initialisation. Otherwise, you should call `recMutexInit` on it and `recMutexClear` when done.

A GRecMutex should only be accessed with the g_rec_mutex_ functions.

Since: 2.32

Synopsis

- newtype RecMutex = RecMutex (ManagedPtr RecMutex)
- newZeroRecMutex :: MonadIO m => m RecMutex
- noRecMutex :: Maybe RecMutex
- recMutexClear :: (HasCallStack, MonadIO m) => RecMutex -> m ()
- recMutexInit :: (HasCallStack, MonadIO m) => RecMutex -> m ()
- recMutexLock :: (HasCallStack, MonadIO m) => RecMutex -> m ()
- recMutexTrylock :: (HasCallStack, MonadIO m) => RecMutex -> m Bool
- recMutexUnlock :: (HasCallStack, MonadIO m) => RecMutex -> m ()

# Exported types

newtype RecMutex Source #

Memory-managed wrapper type.

Constructors

RecMutex (ManagedPtr RecMutex) |

Instances

WrappedPtr RecMutex Source # |
Instance details Defined in GI.GLib.Structs.RecMutex Methods wrappedPtrCalloc :: IO (Ptr RecMutex) Source # wrappedPtrCopy :: RecMutex -> IO RecMutex Source # wrappedPtrFree :: Maybe (FunPtr (Ptr RecMutex -> IO ())) Source #
tag ~ AttrSet => Constructible RecMutex tag Source # |
Instance details Defined in GI.GLib.Structs.RecMutex Methods new :: MonadIO m => (ManagedPtr RecMutex -> RecMutex) -> [AttrOp RecMutex tag] -> m RecMutex Source #

newZeroRecMutex :: MonadIO m => m RecMutex Source #

Construct a `RecMutex` struct initialized to zero.

noRecMutex :: Maybe RecMutex Source #

A convenience alias for `Nothing` :: `Maybe` `RecMutex`.

# Methods

## clear

recMutexClear Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RecMutex | `recMutex`: an initialized `RecMutex`
-> m () |

Frees the resources allocated to a recursive mutex with `recMutexInit`.

This function should not be used with a `RecMutex` that has been statically allocated.

Calling `recMutexClear` on a locked recursive mutex leads to undefined behaviour.

Sine: 2.32

## init

recMutexInit Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RecMutex | `recMutex`: an uninitialized `RecMutex`
-> m () |

Initializes a `RecMutex` so that it can be used.

This function is useful to initialize a recursive mutex that has been allocated on the stack, or as part of a larger structure.

It is not necessary to initialise a recursive mutex that has been statically allocated.

### C code

      typedef struct {
        GRecMutex m;
        ...
      } Blob;

    Blob *b;

    b = g_new (Blob, 1);
    g_rec_mutex_init (&b->m);

Calling `recMutexInit` on an already initialized `RecMutex` leads to undefined behaviour.

To undo the effect of `recMutexInit` when a recursive mutex is no longer needed, use `recMutexClear`.

Since: 2.32

## lock

recMutexLock Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RecMutex | `recMutex`: a `RecMutex`
-> m () |

Locks `recMutex`. If `recMutex` is already locked by another thread, the current thread will block until `recMutex` is unlocked by the other thread. If `recMutex` is already locked by the current thread, the 'lock count' of `recMutex` is increased. The mutex will only become available again when it is unlocked as many times as it has been locked.

Since: 2.32

## trylock

recMutexTrylock Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RecMutex | `recMutex`: a `RecMutex`
-> m Bool | Returns: `True` if `recMutex` could be locked

Tries to lock `recMutex`. If `recMutex` is already locked by another thread, it immediately returns `False`. Otherwise it locks `recMutex` and returns `True`.

Since: 2.32

## unlock

recMutexUnlock Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RecMutex | `recMutex`: a `RecMutex`
-> m () |

Unlocks `recMutex`. If another thread is blocked in a `recMutexLock` call for `recMutex`, it will become unblocked and can lock `recMutex` itself.

Calling `recMutexUnlock` on a recursive mutex that is not locked by the current thread leads to undefined behaviour.

Since: 2.32