Struct Tracker

pub struct Tracker<C>(/* private fields */);

An object used to keep track of controller parts of object-controller pairs.

Implementations

impl<C> Tracker<C>

pub fn new() -> Tracker<C>

Create a new tracker.

Examples found in repository

examples/example2.rs (line 52)

fn main() {
    let mut tracker = Tracker::new();

    let mut threads = Vec::new();

    for i in 1..5 {
        let tracker2 = tracker.clone();
        let thread = std::thread::spawn(move || {
            let (object, controller) = Object::new2(i);
            let object = tracker2.track(object, controller);

            object.do_something();

            println!("Quit {}", i);
        });
        threads.push(thread);
    }

    std::thread::sleep(Duration::from_secs(5));

    tracker.for_each(|r| r.cancel());

    for thread in threads {
        thread.join().unwrap();
    }
}

examples/example1.rs (line 42)

fn main() {
    // Create the tracker object.
    let mut tracker = Tracker::new();

    let tracker2 = tracker.clone();
    let thread = std::thread::spawn(move || {
        // Create an Object-Controller pair in some thread.
        let (object, controller) = Object::new2();

        // Register it with the tracker.
        let object = tracker2.track(object, controller);

        // Do some work with the Object.
        object.do_something();
    });

    std::thread::sleep(Duration::from_secs(5));

    // Cancel all registered Object operations.
    tracker.for_each(|r| r.cancel());

    thread.join().unwrap();
}

pub fn track<T>(&self, object: T, controller: C) -> Tracked<T, C>

Register an object-controller pair.

The controller part is kept in the Tracker, and the object part is wrapped in a Tracked. When the Tracked object is dropped, the controller is dropped too.

Examples found in repository

examples/example2.rs (line 60)

fn main() {
    let mut tracker = Tracker::new();

    let mut threads = Vec::new();

    for i in 1..5 {
        let tracker2 = tracker.clone();
        let thread = std::thread::spawn(move || {
            let (object, controller) = Object::new2(i);
            let object = tracker2.track(object, controller);

            object.do_something();

            println!("Quit {}", i);
        });
        threads.push(thread);
    }

    std::thread::sleep(Duration::from_secs(5));

    tracker.for_each(|r| r.cancel());

    for thread in threads {
        thread.join().unwrap();
    }
}

examples/example1.rs (line 50)

fn main() {
    // Create the tracker object.
    let mut tracker = Tracker::new();

    let tracker2 = tracker.clone();
    let thread = std::thread::spawn(move || {
        // Create an Object-Controller pair in some thread.
        let (object, controller) = Object::new2();

        // Register it with the tracker.
        let object = tracker2.track(object, controller);

        // Do some work with the Object.
        object.do_something();
    });

    std::thread::sleep(Duration::from_secs(5));

    // Cancel all registered Object operations.
    tracker.for_each(|r| r.cancel());

    thread.join().unwrap();
}

pub fn track_pair<T>(&self, pair: (T, C)) -> Tracked<T, C>

Register an object-contoller pair.

Same as track(pair.0, pair.1).

pub fn lock(&mut self) -> TrackerGuard<'_, C>

Lock the tracker so that one can iterate over its controllers.

pub fn for_each<F: FnMut(&C)>(&mut self, f: F)

Call a closure on each tracked controller. The closure must not register a new controller in this tracker, or drop a tracked object. The controllers are visited in an unspecified order.

Examples found in repository

examples/example2.rs (line 71)

fn main() {
    let mut tracker = Tracker::new();

    let mut threads = Vec::new();

    for i in 1..5 {
        let tracker2 = tracker.clone();
        let thread = std::thread::spawn(move || {
            let (object, controller) = Object::new2(i);
            let object = tracker2.track(object, controller);

            object.do_something();

            println!("Quit {}", i);
        });
        threads.push(thread);
    }

    std::thread::sleep(Duration::from_secs(5));

    tracker.for_each(|r| r.cancel());

    for thread in threads {
        thread.join().unwrap();
    }
}

examples/example1.rs (line 59)

fn main() {
    // Create the tracker object.
    let mut tracker = Tracker::new();

    let tracker2 = tracker.clone();
    let thread = std::thread::spawn(move || {
        // Create an Object-Controller pair in some thread.
        let (object, controller) = Object::new2();

        // Register it with the tracker.
        let object = tracker2.track(object, controller);

        // Do some work with the Object.
        object.do_something();
    });

    std::thread::sleep(Duration::from_secs(5));

    // Cancel all registered Object operations.
    tracker.for_each(|r| r.cancel());

    thread.join().unwrap();
}

Trait Implementations

impl<C> Clone for Tracker<C>

fn clone(&self) -> Tracker<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Default for Tracker<C>

fn default() -> Self

Returns the “default value” for a type.