Struct PledgeGuard 

pub struct PledgeGuard<'pledge, T> { /* private fields */ }

Implementations

impl<'pledge, T> PledgeGuard<'pledge, T>

where T: GetUpdate,

pub fn write(&self, u: T::U) -> MaybeClosed<()>

pub fn write_multiples( &self, us: impl IntoIterator<Item = T::U>, ) -> MaybeClosed<()>

Examples found in repository

examples/graph_bfs.rs (lines 22-25)

fn main() {
    let numbers: [_; 32] = std::array::from_fn(|i| i as u32);
    let init = (0, 0, numbers.as_slice());
    let synchronizer = Synchronizer::new(VecDeque::from([init]));
    thread::scope(|scope| {
        for _ in 0..thread::available_parallelism().unwrap().get() {
            scope.spawn(|| {
                for ((current, selected, remaining_slice), writer) in &synchronizer {
                    use std::cmp::Ordering::*;
                    match current.cmp(&TARGET) {
                        Less => {
                            let Some((next, remaining_slice)) = remaining_slice.split_first()
                            else {
                                continue;
                            };
                            writer
                                .write_multiples([
                                    (current + next, (selected << 1) + 1, remaining_slice),
                                    (current, selected << 1, remaining_slice),
                                ])
                                .unwrap();
                        }
                        Equal => {
                            dbg!(current, selected, remaining_slice);
                            synchronizer.close();
                        }
                        Greater => (),
                    }
                }
            });
        }
    })
}

Trait Implementations

impl<'pledge, T: Debug> Debug for PledgeGuard<'pledge, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'pledge, T> Drop for PledgeGuard<'pledge, T>

fn drop(&mut self)

Executes the destructor for this type.