libsync 0.2.0

A library containing channels and other synchronisation object implementations.
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

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

use crate::SharedDetails;

use delegate::delegate;

use std::fmt::Debug;

//#[cfg(feature="count_waiting_senders_and_receivers")]
//use crate::ScopedIncrementer;

///
/// Details that are shared between bounded sender and receiver parts of a channel.
/// 
pub struct BoundedSharedDetails<Q, N = ()>
{

    shared_details: SharedDetails<Q, N>,
    senders_notifier: N,
    //#[cfg(feature="count_waiting_senders_and_receivers")]
    //senders_awaiting_notification_count: AtomicUsize,
    //senders_do_not_wait: AtomicBool

}

impl<Q, N> BoundedSharedDetails<Q, N>
{

    pub fn new(queue: Q, receivers_notifier: N, senders_notifier: N) -> Self
    {

        Self
        {

            shared_details: SharedDetails::new(queue, receivers_notifier),
            senders_notifier,
            //#[cfg(feature="count_waiting_senders_and_receivers")]
            //senders_awaiting_notification_count: AtomicUsize::new(0),
            //senders_do_not_wait: AtomicBool::new(true)

        }

    }

    delegate!
    {

        to self.shared_details
        {

            pub fn queue_ref(&self) -> &Q;
        
            //active_receiver_count
        
            /*
            pub fn inc_active_receiver_count(&self) -> usize;
        
            pub fn dec_active_receiver_count(&self) -> usize;
        
            pub fn current_active_receiver_count(&self) -> usize;
            */

            //
        
            pub fn receivers_notifier_ref(&self) -> &N;

            /*
            pub fn receivers_do_not_wait(&self) -> bool;

            pub fn receivers_do_not_wait_t(&self);

            #[cfg(feature="count_waiting_senders_and_receivers")]
            pub fn temp_inc_receivers_awaiting_notification_count<'a>(&'a self) -> ScopedIncrementer<'a>;
            */

        }

    }
    
    pub fn senders_notifier_ref(&self) -> &N
    {

        &self.senders_notifier

    }

    /*
    pub fn senders_do_not_wait(&self) -> bool
    {

        self.senders_do_not_wait.load(Ordering::Acquire)

    }
    
    pub fn senders_do_not_wait_t(&self)
    {

        self.senders_do_not_wait.store(true, Ordering::Release);

    }

    #[cfg(feature="count_waiting_senders_and_receivers")]
    pub fn temp_inc_senders_awaiting_notification_count<'a>(&'a self) -> ScopedIncrementer<'a>
    {

        ScopedIncrementer::new(&self.senders_awaiting_notification_count) 

    }
    */

}

impl<Q, N> Debug for BoundedSharedDetails<Q, N>
    where Q: Debug,
          N: Debug
{

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BoundedSharedDetails").field("shared_details", &self.shared_details).field("senders_notifier", &self.senders_notifier).finish()
    }
    
}