libsync 0.4.0

Synchronise stuff
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

use std::sync::{Arc, Weak};

use crossbeam_queue::ArrayQueue;

use super::Sender;

use crate::{ChannelSharedDetails, LimitedWakerPermitQueue};



pub struct WeakSender<T>
{

    shared_details: Weak<ChannelSharedDetails<ArrayQueue<T>, LimitedWakerPermitQueue>>,
    senders_count: Weak<()>,
    receivers_count: Weak<()>

}

impl<T> WeakSender<T>
{

    pub fn new(shared_details: &Arc<ChannelSharedDetails<ArrayQueue<T>, LimitedWakerPermitQueue>>, senders_count: &Arc<()>, receivers_count: &Weak<()>) -> Self
    {

        Self
        {

            shared_details: Arc::downgrade(shared_details),
            senders_count: Arc::downgrade(senders_count),
            receivers_count: receivers_count.clone()

        }

    }
    
    pub fn upgrade(&self) -> Option<Sender<T>>
    {

        if let Some(shared_details) = self.shared_details.upgrade() && let Some(senders_count) = self.senders_count.upgrade()
        {

            Some(Sender::new(shared_details, senders_count, self.receivers_count.clone()))

        }
        else
        {

            None
            
        }

    }

    ///
    /// The total number of Sender instances.
    /// 
    pub fn strong_count(&self) -> usize
    {

        self.senders_count.strong_count()

    }

    ///
    /// The total number of potential Sender instances.
    /// 
    pub fn weak_count(&self) -> usize
    {

        self.senders_count.weak_count()
        
    }

}