Cocoa Beans 0.0.54-beta0 Help

🥸 Watcher

Available Since 0.0.39

After we have made our reactive state its time to put the final piece in the puzzle - watchers. Watchers allow us trigger external operations when the state changes.

@Test void watch() { MutableObservable<Integer> observable = Observable.mutable(1); AtomicInteger count = new AtomicInteger(); // we need to create a watcher manager, every watcher needs to be attached to it WatcherManager watcherManager = new WatcherManager(); // our watcher performs some checks and increments the count variable // The attached watcher object allows as to cancel the watcher AttachedWatcher<Integer> watcher = observable.lazyWatch(watcherManager, num -> { switch (count.get()) { case 0 -> assertEquals(1, num); case 1 -> assertEquals(8, num); case 2 -> assertEquals(67, num); default -> fail(); } count.incrementAndGet(); }); // for anything to happen, we have to call the heartbeat method // It will trigger every watcher attached to the manager that was flagged as dirty watcherManager.heartbeat(); // 1 watcherManager.heartbeat(); // No new data watcherManager.heartbeat(); // No new data observable.set(8); watcherManager.heartbeat(); // 8 watcherManager.heartbeat(); // No new data observable.set(4); observable.set(67); watcherManager.heartbeat(); // 67 observable.set(8); observable.set(67); watcherManager.heartbeat(); // No new data watcher.detach(); // Detach watcher from manager assertFalse(watcher.isAttached()); // Make sure it detach }

Re-attaching Watchers

Available Since 0.0.52

An AttachedWatcher can be detached from its current operator and re-attached to a different one. This is useful when you need to move a watcher between managers, for example when transferring ownership of a game loop or switching execution contexts.

Once detached, the watcher will no longer be triggered by the original operator's heartbeat. After re-attaching to a new operator, the watcher will respond to the new operator's heartbeat instead.

@Test void reAttachWatcher() { MutableObservable<Integer> observable = Observable.mutable(1); AtomicInteger count = new AtomicInteger(); WatcherManager firstManager = new WatcherManager(); WatcherManager secondManager = new WatcherManager(); AttachedWatcher<Integer> watcher = observable.lazyWatch(firstManager, num -> { count.incrementAndGet(); }); // watcher reacts to the first manager's heartbeat firstManager.heartbeat(); assertEquals(1, count.get()); observable.set(10); firstManager.heartbeat(); assertEquals(2, count.get()); // detach from the first manager watcher.detach(); // first manager no longer triggers the watcher observable.set(20); firstManager.heartbeat(); assertEquals(2, count.get()); // re-attach to a different manager watcher.attach(secondManager); // now the second manager drives the watcher observable.set(25); secondManager.heartbeat(); assertEquals(3, count.get()); observable.set(30); secondManager.heartbeat(); assertEquals(4, count.get()); watcher.detach(); }
Last modified: 03 July 2026