Gist 6ec7e2d2e5b12c1bce0d09b7faa51ee2

100%

Gist 6ec7e2d2e5b12c1bce0d09b7faa51ee2

✓ Published0🌍 Public

Last edited May 25, 2018

Created on May 25, 2018

This example demonstrates a key-value observing (KVO) binding mechanism in Swift, where changes to a property on one NSObject subclass (Foo.bar) automatically update a property on another (Zoq.fot). The code uses the Foundation framework, specifically the `observe(_:options:changeHandler:)` method with KeyPaths, and stores a `Disposable` object via `objc_setAssociatedObject` to manage observation lifecycle. Reassigning the target object (Zoq) triggers the `Disposable` deinit, which invalidates the observation and stops further updates, as shown by the printed deinit messages and unchanged `fot` values after reassignment.

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

54% match

Loading thumbnail…

Gist 54292

This example demonstrates how Ruby’s `instance_variable_set` and `instance_variable_get` can dynamically alter and read an instance variable defined on a class, using a module-scoped `@foo` that starts as `"bar"` and is changed to `"changed"` via a nested class method. The code defines a `What` module containing `@foo` and a `Whatever` class whose `change_foo` method mutates that variable, then prints its initial and updated values using `p`. The output, shown as comments (`# >> "bar"` and `# >> "changed"`), confirms the state change. No external libraries or rendering APIs are used; the example relies solely on Ruby’s core object model and metaprogramming features.

DDylanFM

52% 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

50% match

Loading thumbnail…

Swift protocol and extensions for adding support to closures in UIKit classes. Extension support for UIButton, UIGestureRecognizer, UIBarButtonItem etc. Swift 3.0.

This example demonstrates a Swift protocol that adds closure-based event handling to UIKit classes, replacing traditional target-action patterns. Code extensions for UIButton, UIPageControl, UIGestureRecognizer, and UIBarButtonItem use the Closurable protocol to wrap callbacks in a ClosureContainer object, stored via objc_setAssociatedObject. The container exposes an @objc selector that invokes the stored closure, allowing UIKit to call the handler dynamically. The code pairs each UI component’s standard addTarget or initializer with custom convenience methods, keeping the call site concise. No external libraries are required; the implementation relies solely on Swift 3.0 and the Objective-C runtime.

MMoximillian

49% match

Loading thumbnail…

Example of how init/func behaves in protocols and protocol extensions

This example demonstrates how Swift handles `init` and `func` declarations in protocols versus protocol extensions. It defines two similar protocol pairs—one where `P1` declares both members, and another where `P2` is empty and relies entirely on its extension—to show that a struct’s own implementations always take precedence over those in the extension. The code creates instances of `S1` and `S2` and calls their methods, printing "S1 init"/"S1 func" and "S2 init"/"S2 func" respectively, proving that the extension’s fallback implementations are never invoked when the struct provides its own.

MMoximillian

47% match

Loading thumbnail…

Gist 402351

This example shows an Objective-C class definition, `ITCocoaWindowAdapter`, which subclasses `NSWindow` to manage a window reference and event handling. The code declares an `OpaqueWindowPtr` structure and an `OpaqueEventHandlerRef` to track the underlying Carbon window and event handler, alongside flags for focus searching and drawing via HIView. It includes an `NSGraphicsContext` for drawing operations. The snippet relies on the AppKit and Carbon APIs, specifically `NSWindow`, `NSGraphicsContext`, and opaque pointer types, to adapt Cocoa window behavior for legacy drawing and event processing. The visualization is a static code listing without data or rendering logic.

CCaged

47% match

Loading thumbnail…

Internal API Inspection

This example visualizes the internal structure of an Objective-C object by dumping its class hierarchy, properties, methods, and protocols. It uses the Mocha framework (via `[obj class].mocha()`) to query the runtime and displays the results as a tree through `obj.treeAsDictionary()`. The visualization shows the object’s properties, class methods, instance methods, and protocols, both with and without ancestor inheritance. The data is generated dynamically from the live object, with log output structured for inspection, making it a tool for debugging and exploring API internals.

KKevinGutowski

47% match

Loading thumbnail…

Swift class constants are mutable within the initialiser

This example demonstrates that Swift class constants, declared with `let`, can be assigned multiple times within the initialiser, despite being immutable elsewhere. The code defines a `Bar` class with an uninitialized `myConstant` field, then sets it to 77 and 45 before calling `super.init()`, and finally reassigns it to 55 after that call. A `doSomething()` method shows that further mutation outside the initialiser is prohibited. The example is a raw Swift source file from a gist, run as a standalone script.

CColinEberhardt

47% match