unsend 0.2.1

A thread unsafe runtime for thread unsafe people
Documentation 
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

// SPDX-License-Identifier: LGPL-3.0-or-later OR MPL-2.0
// This file is a part of `unsend`.
//
// `unsend` is free software: you can redistribute it and/or modify it under the
// terms of either:
//
// * GNU Lesser General Public License as published by the Free Software Foundation, either
//   version 3 of the License, or (at your option) any later version.
// * Mozilla Public License as published by the Mozilla Foundation, version 2.
// * The Patron License (https://github.com/notgull/unsend/blob/main/LICENSE-PATRON.md)
//   for sponsors and contributors, who can ignore the copyleft provisions of the above licenses
//   for this project.
//
// `unsend` is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU Lesser General Public License or the Mozilla Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License and the Mozilla
// Public License along with `unsend`. If not, see <https://www.gnu.org/licenses/>.

//! Asynchronous semaphore.

use crate::{Event, EventListener};

use core::cell::Cell;
use core::pin::Pin;

#[cfg(feature = "alloc")]
use alloc::rc::Rc;

/// An asynchronous semaphore.
pub struct Semaphore {
    /// The event for waiting on the semaphore.
    event: Event<()>,

    /// The number of permits.
    permits: Cell<usize>,
}

/// A guard that releases the permit when dropped.
pub struct SemaphoreGuard<'a> {
    /// The origin semaphore.
    semaphore: &'a Semaphore,
}

/// A guard that releases the permit when dropped.
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub struct SemaphoreGuardRc {
    /// The origin semaphore.
    semaphore: Rc<Semaphore>,
}

impl Semaphore {
    /// Creates a new asynchronous semaphore.
    pub fn new(permits: usize) -> Semaphore {
        Semaphore {
            event: Event::new(),
            permits: Cell::new(permits),
        }
    }

    /// Try to acquire a permit.
    pub fn try_acquire(&self) -> Option<SemaphoreGuard<'_>> {
        let permits = self.permits.get();
        if permits > 0 {
            self.permits.set(permits - 1);
            Some(SemaphoreGuard { semaphore: self })
        } else {
            None
        }
    }

    /// Try to acquire a permit through an `Rc`.
    #[cfg(feature = "alloc")]
    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
    pub fn try_acquire_rc(self: Rc<Self>) -> Option<SemaphoreGuardRc> {
        let permits = self.permits.get();
        if permits > 0 {
            self.permits.set(permits - 1);
            Some(SemaphoreGuardRc { semaphore: self })
        } else {
            None
        }
    }

    /// Acquire a permit.
    pub async fn acquire(&self) -> SemaphoreGuard<'_> {
        let mut listener = EventListener::new(&self.event);

        {
            let mut listener = unsafe { Pin::new_unchecked(&mut listener) };

            loop {
                if let Some(guard) = self.try_acquire() {
                    return guard;
                }

                listener.as_mut().await;
            }
        }
    }

    /// Acquire a permit through an `Rc`.
    #[cfg(feature = "alloc")]
    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
    pub async fn acquire_rc(self: Rc<Self>) -> SemaphoreGuardRc {
        let mut listener = EventListener::new(&self.event);

        {
            let mut listener = unsafe { Pin::new_unchecked(&mut listener) };

            loop {
                if let Some(guard) = self.clone().try_acquire_rc() {
                    return guard;
                }

                listener.as_mut().await;
            }
        }
    }
}

impl Drop for SemaphoreGuard<'_> {
    fn drop(&mut self) {
        self.semaphore.permits.set(self.semaphore.permits.get() + 1);
        self.semaphore.event.notify(1);
    }
}

#[cfg(feature = "alloc")]
impl Drop for SemaphoreGuardRc {
    fn drop(&mut self) {
        self.semaphore.permits.set(self.semaphore.permits.get() + 1);
        self.semaphore.event.notify(1);
    }
}