1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
use crate::sys::rwlock as imp; /// An OS-based reader-writer lock. /// /// This structure is entirely unsafe and serves as the lowest layer of a /// cross-platform binding of system rwlocks. It is recommended to use the /// safer types at the top level of this crate instead of this type. pub struct RWLock(imp::RWLock); impl RWLock { /// Creates a new reader-writer lock for use. /// /// Behavior is undefined if the reader-writer lock is moved after it is /// first used with any of the functions below. pub const fn new() -> RWLock { RWLock(imp::RWLock::new()) } /// Acquires shared access to the underlying lock, blocking the current /// thread to do so. /// /// Behavior is undefined if the rwlock has been moved between this and any /// previous method call. #[inline] pub unsafe fn read(&self) { self.0.read() } /// Attempts to acquire shared access to this lock, returning whether it /// succeeded or not. /// /// This function does not block the current thread. /// /// Behavior is undefined if the rwlock has been moved between this and any /// previous method call. #[inline] pub unsafe fn try_read(&self) -> bool { self.0.try_read() } /// Acquires write access to the underlying lock, blocking the current thread /// to do so. /// /// Behavior is undefined if the rwlock has been moved between this and any /// previous method call. #[inline] pub unsafe fn write(&self) { self.0.write() } /// Attempts to acquire exclusive access to this lock, returning whether it /// succeeded or not. /// /// This function does not block the current thread. /// /// Behavior is undefined if the rwlock has been moved between this and any /// previous method call. #[inline] pub unsafe fn try_write(&self) -> bool { self.0.try_write() } /// Unlocks previously acquired shared access to this lock. /// /// Behavior is undefined if the current thread does not have shared access. #[inline] pub unsafe fn read_unlock(&self) { self.0.read_unlock() } /// Unlocks previously acquired exclusive access to this lock. /// /// Behavior is undefined if the current thread does not currently have /// exclusive access. #[inline] pub unsafe fn write_unlock(&self) { self.0.write_unlock() } /// Destroys OS-related resources with this RWLock. /// /// Behavior is undefined if there are any currently active users of this /// lock. #[inline] pub unsafe fn destroy(&self) { self.0.destroy() } } // the cfg annotations only exist due to dead code warnings. the code itself is portable #[cfg(unix)] pub struct StaticRWLock(RWLock); #[cfg(unix)] impl StaticRWLock { pub const fn new() -> StaticRWLock { StaticRWLock(RWLock::new()) } /// Acquires shared access to the underlying lock, blocking the current /// thread to do so. /// /// The lock is automatically unlocked when the returned guard is dropped. #[inline] pub fn read_with_guard(&'static self) -> RWLockReadGuard { // SAFETY: All methods require static references, therefore self // cannot be moved between invocations. unsafe { self.0.read(); } RWLockReadGuard(&self.0) } /// Acquires write access to the underlying lock, blocking the current thread /// to do so. /// /// The lock is automatically unlocked when the returned guard is dropped. #[inline] pub fn write_with_guard(&'static self) -> RWLockWriteGuard { // SAFETY: All methods require static references, therefore self // cannot be moved between invocations. unsafe { self.0.write(); } RWLockWriteGuard(&self.0) } } #[cfg(unix)] pub struct RWLockReadGuard(&'static RWLock); #[cfg(unix)] impl Drop for RWLockReadGuard { fn drop(&mut self) { unsafe { self.0.read_unlock() } } } #[cfg(unix)] pub struct RWLockWriteGuard(&'static RWLock); #[cfg(unix)] impl Drop for RWLockWriteGuard { fn drop(&mut self) { unsafe { self.0.write_unlock() } } }