Using Boost Signals2 to pass messages, return true to cancel propagation

100%

Using Boost Signals2 to pass messages, return true to cancel propagation

✓ Published0🌍 Public

Last edited Dec 8, 2011

Created on Dec 7, 2011

This example demonstrates how to cancel signal propagation in Boost Signals2 by using a custom combiner that inspects an event object and stops iteration when `stopPropagation()` is called. It shows three widget slots connected to a single signal, with a goat-canceling widget that halts delivery of "goat" events to subsequent slots, while other event types like "otter" and "badger" propagate normally. The code defines a `MyCombiner` struct that checks the event’s `shouldStopPropagation()` flag between slot invocations, and also uses `shared_connection_block` to temporarily suppress a slot. The output confirms that only widgets 1 and 2 receive goat events, while all three receive otter and badger events.

AI-generated description

Similar vizzes

Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt

45% match

Loading thumbnail…

Gist 5246946

This example demonstrates how the Mediator pattern enables communication between Backbone views without direct coupling. A ToolbarView triggers a global event named `somethingHappened` with a data object via `Backbone.trigger()`, while a TableView subscribes to that event using `Backbone.on()` in its `initialize` method and unsubscribes with `Backbone.off()` in its `destroy` method. The code uses the Backbone event bus as a mediator, showing both the classic `on`/`off` API and mentions the newer `listenTo` alternative.

MModuloM

41% match

Loading thumbnail…

requirebin sketch

This example demonstrates a simple event-driven messaging system using the Barracks library. It shows how multiple listeners can respond to the same named event, with two separate handlers writing personalized greetings to the document. The code creates a dispatcher instance, registers two 'hello' listeners, and triggers the event with the name 'Loki'. The visualization highlights the sequence of output generated by both listeners when the event fires.

HHypercubed

40% match

Loading thumbnail…

Gist c4276ed96ff4bd575933c7ad390a7a92

This example demonstrates a custom event-dispatch loop using the D3 dispatch module. It creates a `dispatch` object with a `foo` event, registers a handler, and then triggers that event 3,000 times via `dispatch.call`. The handler checks whether the passed argument is `undefined` and prints a message if so. The page displays the total number of times the handler was called. The code relies on `d3_dispatch.dispatch` and the `on`/`call` methods to manage custom event flow, with no external data source.

HHypercubed

40% match

Loading thumbnail…

Hello Reactor

This example demonstrates a minimal event-driven communication system built with JavaScript. It shows how two listeners attached to the same `'big bang'` event respond to a dispatched payload, with one listener logging a fixed message and the other printing the passed arguments. The code defines a custom `Reactor` class and an `Event` class, showcasing manual event registration, callback storage, and dispatch logic. The implementation relies on JavaScript's array `forEach` method to invoke all registered callbacks with the spread `...eventArgs` syntax. The data originates from a hardcoded dispatch call passing the values `135`, `'test'`, and `[1, 2, 3]`.

MMAKIO135

39% match

Loading thumbnail…

Gist 7026512

This example demonstrates object-oriented JavaScript patterns for modeling zoo animals, showing how constructor functions and prototypes create shared behavior. The code defines an `Animal` constructor with `identify()` and `name()` methods on its prototype, while a `Zoo` object manages collections of animals. Although the zoo methods contain incomplete logic, the driver code tests animal identification, leg counts, and prototype method sharing across instances. The example uses plain JavaScript—no external libraries—relying on `console.log` for output and a custom `assert` function for validation. It illustrates inheritance and code reuse, though the zoo aggregation methods remain non-functional as written.

EElaineYu

38% match

Loading thumbnail…

Shared via Rust Playground

This example simulates a concurrent breakfast scenario using Rust's standard library. It shows how multiple attendee threads send bagels through channels to a single toaster thread, which toasts them and returns them via acknowledgment channels. The visualization highlights thread synchronization and message passing with `std::thread::spawn`, `std::sync::mpsc::channel`, and channel send/receive operations. The code prints toasting progress and final consumption messages, illustrating the choreography of concurrent tasks through inter-thread communication. No external libraries or data sources are used; the rendering is purely textual output from the console.

FFranklin Chen

38% match

Loading thumbnail…

EventsSpeedTests

This example demonstrates how a single property added to one function—but not all functions—can trigger V8’s “failed to optimize dispatch” warning in a hot loop. It shows the impact of monomorphic versus polymorphic call-sites for `Function.prototype.apply` when dispatching to multiple callbacks. The code runs 2 million iterations of a `dispatch` function that invokes two callbacks, comparing an unoptimized case, a bound-function variant, and a fixed version using `.bind(0)` to enforce a monomorphic apply site. The included HTML interface and Node command-line tests let users measure execution time differences across the three approaches.

HHypercubed

38% match