[][src]Crate object_controller_tracker

A crate used to keep track of Object-Controller pairs, where a Controller is used to operate on the Object (e.g. to cancel it), usually from an other thread.

A Tracker object is constructed and used to register Object-Controller pairs. When an Object is dropped, the Controller is automatically unregistered. The Tracker object can be used to operate on all registered objects through their associated controllers.


// The object we want to track...
struct Object {
    stop: Arc<AtomicBool>,

// ... and its associated controller.
struct Controller(Arc<AtomicBool>);

impl Object {

    // Create an Object-Controller pair.
    fn new2() -> (Object, Controller) {
        let stop = Arc::new(AtomicBool::new(false));
        let ctl_stop = Arc::clone(&stop);
        (Object { stop }, Controller(ctl_stop))

    // Some method on the object that can be cancelled through the Controller.
    fn do_something(&self) {
        while !self.stop.load(Ordering::SeqCst) {
            println!("Do something.");

impl Controller {
    // Cancel an operation on the Object.
    fn cancel(&self) {
        self.0.store(true, Ordering::SeqCst);

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.


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




An iterator over the tracked controllers. Controllers are visited in an unspecified order.


Wrapper for the object part of tracked object-controller pair.


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


An RAII implementation of a Tracker lock. When this structure goes out of scope, the lock is released.