/** * g_static_rec_mutex_unlock: * @mutex: a #GStaticRecMutex to unlock. * * Unlocks @mutex. Another thread will be allowed to lock @mutex only * when it has been unlocked as many times as it had been locked * before. If @mutex is completely unlocked and another thread is * blocked in a g_static_rec_mutex_lock() call for @mutex, it will be * woken and can lock @mutex itself. * * Deprecated: 2.32: Use g_rec_mutex_unlock() */ void g_static_rec_mutex_unlock (GStaticRecMutex* mutex) { GRecMutex *rm; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); mutex->depth--; g_rec_mutex_unlock (rm); }
/** * g_static_rec_mutex_lock_full: * @mutex: a #GStaticRecMutex to lock. * @depth: number of times this mutex has to be unlocked to be * completely unlocked. * * Works like calling g_static_rec_mutex_lock() for @mutex @depth times. * * Deprecated: 2.32: Use g_rec_mutex_lock() */ void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, guint depth) { GRecMutex *rm; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); while (depth--) { g_rec_mutex_lock (rm); mutex->depth++; } }
/** * g_static_rec_mutex_trylock: * @mutex: a #GStaticRecMutex to lock. * * Tries to lock @mutex. If @mutex is already locked by another thread, * it immediately returns %FALSE. Otherwise it locks @mutex and returns * %TRUE. If @mutex is already locked by the calling thread, this * functions increases the depth of @mutex and immediately returns * %TRUE. * * Returns: %TRUE, if @mutex could be locked. * * Deprecated: 2.32: Use g_rec_mutex_trylock() */ gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex) { GRecMutex *rm; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); if (g_rec_mutex_trylock (rm)) { mutex->depth++; return TRUE; } else return FALSE; }
/** * g_static_rec_mutex_unlock_full: * @mutex: a #GStaticRecMutex to completely unlock. * @Returns: number of times @mutex has been locked by the current * thread. * * Completely unlocks @mutex. If another thread is blocked in a * g_static_rec_mutex_lock() call for @mutex, it will be woken and can * lock @mutex itself. This function returns the number of times that * @mutex has been locked by the current thread. To restore the state * before the call to g_static_rec_mutex_unlock_full() you can call * g_static_rec_mutex_lock_full() with the depth returned by this * function. * * Deprecated: 2.32: Use g_rec_mutex_unlock() */ guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex) { GRecMutex *rm; gint depth; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); depth = mutex->depth; while (mutex->depth) { mutex->depth--; g_rec_mutex_unlock (rm); } return depth; }
/** * g_static_rec_mutex_unlock_full: * @mutex: a #GStaticRecMutex to completely unlock. * * Completely unlocks @mutex. If another thread is blocked in a * g_static_rec_mutex_lock() call for @mutex, it will be woken and can * lock @mutex itself. This function returns the number of times that * @mutex has been locked by the current thread. To restore the state * before the call to g_static_rec_mutex_unlock_full() you can call * g_static_rec_mutex_lock_full() with the depth returned by this * function. * * Returns: number of times @mutex has been locked by the current * thread. * * Deprecated: 2.32: Use g_rec_mutex_unlock() */ guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex) { GRecMutex *rm; gint depth; gint i; rm = g_static_rec_mutex_get_rec_mutex_impl (mutex); /* all access to mutex->depth done while still holding the lock */ depth = mutex->depth; i = mutex->depth; mutex->depth = 0; while (i--) g_rec_mutex_unlock (rm); return depth; }