try-lock-0.2.5/.cargo_vcs_info.json0000644000000001360000000000100126040ustar { "git": { "sha1": "fd160ecd9105e8afcc43dbea450a0ef6e5128cce" }, "path_in_vcs": "" }try-lock-0.2.5/.github/workflows/CI.yml000064400000000000000000000011461046102023000160110ustar 00000000000000name: CI on: pull_request: push: branches: - master jobs: test: name: Test ${{ matrix.rust }} strategy: matrix: rust: - stable - beta - nightly - 1.31.0 runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v1 - name: Install Rust (${{ matrix.rust }}) uses: actions-rs/toolchain@v1 with: profile: minimal toolchain: ${{ matrix.rust }} override: true - name: Test uses: actions-rs/cargo@v1 with: command: test try-lock-0.2.5/.gitignore000064400000000000000000000000371046102023000133640ustar 00000000000000 /target **/*.rs.bk Cargo.lock try-lock-0.2.5/Cargo.toml0000644000000016060000000000100106050ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] name = "try-lock" version = "0.2.5" authors = ["Sean McArthur "] description = "A lightweight atomic lock." homepage = "https://github.com/seanmonstar/try-lock" documentation = "https://docs.rs/try-lock" readme = "README.md" keywords = [ "lock", "atomic", ] categories = [ "concurrency", "no-std", ] license = "MIT" repository = "https://github.com/seanmonstar/try-lock" [dependencies] try-lock-0.2.5/Cargo.toml.orig000064400000000000000000000007001046102023000142600ustar 00000000000000[package] name = "try-lock" version = "0.2.5" # remember to update html_root_url description = "A lightweight atomic lock." keywords = ["lock", "atomic"] categories = ["concurrency", "no-std"] authors = ["Sean McArthur "] license = "MIT" repository = "https://github.com/seanmonstar/try-lock" homepage = "https://github.com/seanmonstar/try-lock" documentation = "https://docs.rs/try-lock" readme = "README.md" [dependencies] try-lock-0.2.5/LICENSE000064400000000000000000000021101046102023000123730ustar 00000000000000Copyright (c) 2018-2023 Sean McArthur Copyright (c) 2016 Alex Crichton Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. try-lock-0.2.5/README.md000064400000000000000000000016361046102023000126610ustar 00000000000000# TryLock - [Crates.io](https://crates.io/crates/try-lock) - [Docs](https://docs.rs/try-lock) A light-weight lock guarded by an atomic boolean. Most efficient when contention is low, acquiring the lock is a single atomic swap, and releasing it just 1 more atomic swap. ## Example ```rust use std::sync::Arc; use try_lock::TryLock; // a thing we want to share struct Widget { name: String, } // lock it up! let widget1 = Arc::new(TryLock::new(Widget { name: "Spanner".into(), })); let widget2 = widget1.clone(); // mutate the widget let mut locked = widget1.try_lock().expect("example isn't locked yet"); locked.name.push_str(" Bundle"); // hands off, buddy let not_locked = widget2.try_lock(); assert!(not_locked.is_none(), "widget1 has the lock"); // ok, you can have it drop(locked); let locked2 = widget2.try_lock().expect("widget1 lock is released"); assert_eq!(locked2.name, "Spanner Bundle"); ``` try-lock-0.2.5/src/lib.rs000064400000000000000000000176461046102023000133150ustar 00000000000000#![deny(missing_docs)] #![deny(missing_debug_implementations)] #![deny(warnings)] #![cfg_attr(not(test), no_std)] //! A light-weight lock guarded by an atomic boolean. //! //! Most efficient when contention is low, acquiring the lock is a single //! atomic swap, and releasing it just 1 more atomic swap. //! //! # Example //! //! ``` //! use std::sync::Arc; //! use try_lock::TryLock; //! //! // a thing we want to share //! struct Widget { //! name: String, //! } //! //! // lock it up! //! let widget1 = Arc::new(TryLock::new(Widget { //! name: "Spanner".into(), //! })); //! //! let widget2 = widget1.clone(); //! //! //! // mutate the widget //! let mut locked = widget1.try_lock().expect("example isn't locked yet"); //! locked.name.push_str(" Bundle"); //! //! // hands off, buddy //! let not_locked = widget2.try_lock(); //! assert!(not_locked.is_none(), "widget1 has the lock"); //! //! // ok, you can have it //! drop(locked); //! //! let locked2 = widget2.try_lock().expect("widget1 lock is released"); //! //! assert_eq!(locked2.name, "Spanner Bundle"); //! ``` #[cfg(test)] extern crate core; use core::cell::UnsafeCell; use core::fmt; use core::ops::{Deref, DerefMut}; use core::sync::atomic::{AtomicBool, Ordering}; use core::marker::PhantomData; /// A light-weight lock guarded by an atomic boolean. /// /// Most efficient when contention is low, acquiring the lock is a single /// atomic swap, and releasing it just 1 more atomic swap. /// /// It is only possible to try to acquire the lock, it is not possible to /// wait for the lock to become ready, like with a `Mutex`. #[derive(Default)] pub struct TryLock { is_locked: AtomicBool, value: UnsafeCell, } impl TryLock { /// Create a `TryLock` around the value. #[inline] pub const fn new(val: T) -> TryLock { TryLock { is_locked: AtomicBool::new(false), value: UnsafeCell::new(val), } } /// Try to acquire the lock of this value. /// /// If the lock is already acquired by someone else, this returns /// `None`. You can try to acquire again whenever you want, perhaps /// by spinning a few times, or by using some other means of /// notification. /// /// # Note /// /// The default memory ordering is to use `Acquire` to lock, and `Release` /// to unlock. If different ordering is required, use /// [`try_lock_explicit`](TryLock::try_lock_explicit) or /// [`try_lock_explicit_unchecked`](TryLock::try_lock_explicit_unchecked). #[inline] pub fn try_lock(&self) -> Option> { unsafe { self.try_lock_explicit_unchecked(Ordering::Acquire, Ordering::Release) } } /// Try to acquire the lock of this value using the lock and unlock orderings. /// /// If the lock is already acquired by someone else, this returns /// `None`. You can try to acquire again whenever you want, perhaps /// by spinning a few times, or by using some other means of /// notification. #[inline] #[deprecated( since = "0.2.3", note = "This method is actually unsafe because it unsafely allows \ the use of weaker memory ordering. Please use try_lock_explicit instead" )] pub fn try_lock_order(&self, lock_order: Ordering, unlock_order: Ordering) -> Option> { unsafe { self.try_lock_explicit_unchecked(lock_order, unlock_order) } } /// Try to acquire the lock of this value using the specified lock and /// unlock orderings. /// /// If the lock is already acquired by someone else, this returns /// `None`. You can try to acquire again whenever you want, perhaps /// by spinning a few times, or by using some other means of /// notification. /// /// # Panic /// /// This method panics if `lock_order` is not any of `Acquire`, `AcqRel`, /// and `SeqCst`, or `unlock_order` is not any of `Release` and `SeqCst`. #[inline] pub fn try_lock_explicit(&self, lock_order: Ordering, unlock_order: Ordering) -> Option> { match lock_order { Ordering::Acquire | Ordering::AcqRel | Ordering::SeqCst => {} _ => panic!("lock ordering must be `Acquire`, `AcqRel`, or `SeqCst`"), } match unlock_order { Ordering::Release | Ordering::SeqCst => {} _ => panic!("unlock ordering must be `Release` or `SeqCst`"), } unsafe { self.try_lock_explicit_unchecked(lock_order, unlock_order) } } /// Try to acquire the lock of this value using the specified lock and /// unlock orderings without checking that the specified orderings are /// strong enough to be safe. /// /// If the lock is already acquired by someone else, this returns /// `None`. You can try to acquire again whenever you want, perhaps /// by spinning a few times, or by using some other means of /// notification. /// /// # Safety /// /// Unlike [`try_lock_explicit`], this method is unsafe because it does not /// check that the given memory orderings are strong enough to prevent data /// race. /// /// [`try_lock_explicit`]: Self::try_lock_explicit #[inline] pub unsafe fn try_lock_explicit_unchecked(&self, lock_order: Ordering, unlock_order: Ordering) -> Option> { if !self.is_locked.swap(true, lock_order) { Some(Locked { lock: self, order: unlock_order, _p: PhantomData, }) } else { None } } /// Take the value back out of the lock when this is the sole owner. #[inline] pub fn into_inner(self) -> T { debug_assert!(!self.is_locked.load(Ordering::Relaxed), "TryLock was mem::forgotten"); self.value.into_inner() } } unsafe impl Send for TryLock {} unsafe impl Sync for TryLock {} impl fmt::Debug for TryLock { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Used if the TryLock cannot acquire the lock. struct LockedPlaceholder; impl fmt::Debug for LockedPlaceholder { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("") } } let mut builder = f.debug_struct("TryLock"); if let Some(locked) = self.try_lock() { builder.field("value", &*locked); } else { builder.field("value", &LockedPlaceholder); } builder.finish() } } /// A locked value acquired from a `TryLock`. /// /// The type represents an exclusive view at the underlying value. The lock is /// released when this type is dropped. /// /// This type derefs to the underlying value. #[must_use = "TryLock will immediately unlock if not used"] pub struct Locked<'a, T: 'a> { lock: &'a TryLock, order: Ordering, /// Suppresses Send and Sync autotraits for `struct Locked`. _p: PhantomData<*mut T>, } impl<'a, T> Deref for Locked<'a, T> { type Target = T; #[inline] fn deref(&self) -> &T { unsafe { &*self.lock.value.get() } } } impl<'a, T> DerefMut for Locked<'a, T> { #[inline] fn deref_mut(&mut self) -> &mut T { unsafe { &mut *self.lock.value.get() } } } impl<'a, T> Drop for Locked<'a, T> { #[inline] fn drop(&mut self) { self.lock.is_locked.store(false, self.order); } } impl<'a, T: fmt::Debug> fmt::Debug for Locked<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&**self, f) } } #[cfg(test)] mod tests { use super::TryLock; #[test] fn fmt_debug() { let lock = TryLock::new(5); assert_eq!(format!("{:?}", lock), "TryLock { value: 5 }"); let locked = lock.try_lock().unwrap(); assert_eq!(format!("{:?}", locked), "5"); assert_eq!(format!("{:?}", lock), "TryLock { value: }"); } }