A replacement for NSNotificationCenter#addObserver
and NSObject#addObserver
that is type-safe and not verbose.
import EmitterKit
// A generic event emitter (but type-safe)!
var event = Event<T>()
// Any emitted data must be the correct type.
event.emit(data)
// This listener will only be called once.
// You are *not* required to retain it.
event.once { data: T in
print(data)
}
// This listener won't stop listening;
// unless you stop it manually,
// or its Event<T> is deallocated.
// You *are* required to retain it.
var listener = event.on { data: T in
print(data)
}
// Stop the listener manually.
listener.isListening = false
// Restart the listener (if it was stopped).
listener.isListening = true
A target allows you to associate a specific AnyObject
with an emit
call. This is useful when emitting events associated with classes you can't add properties to (like UIView
).
When calling emit
with a target, you must also call on
or once
with the same target in order to receive the emitted event.
let myView = UIView()
let didTouch = Event<UITouch>()
didTouch.once(myView) { touch in
print(touch)
}
didTouch.emit(myView, touch)
The Notifier
class helps when you are forced to use NSNotificationCenter
(for example, if you want to know when the keyboard has appeared).
// You are **not** required to retain this after creating your listener.
var event = Notifier(UIKeyboardWillShowNotification)
// Handle NSNotifications with style!
listener = event.on { (notif: Notification) in
print(notif.userInfo)
}
// Any NSObject descendant will work.
var view = UIView()
// "Make KVO great again!" - Donald Trump
listener = view.on("bounds") { (change: Change<CGRect>) in
print(change)
}
The following actions must be done on the same thread, or you need manual locking:
- Emit an event
- Add/remove a listener
- Set the
isListening
property of a listener
- Fixed protocol casting (#60)
- Fix Carthage compatibility for non iOS platforms
- Added the
Event.getListeners
method - Listeners are now always called in the order they were added
- Event.emit() can be called without an argument
- Carthage support has been improved
-
The
NotificationListener
class now takes aNotification
instead of anNSDictionary
. -
A
NotificationListener
without a target will now receive everyNotification
with its name, regardless of the value ofnotif.object
.
-
Swift 3.0 + Xcode 8.0 beta 6 support
-
The
Signal
class was removed. (useEvent<Void>
instead) -
The
Emitter
abstract class was removed. -
The
EmitterListener
class was renamedEventListener<T>
. -
The
Event<T>
class no longer has a superclass. -
The
Notification
class was renamedNotifier
(to prevent collision withFoundation.Notification
). -
The
on
andonce
methods ofEvent<T>
now return anEventListener<T>
(instead of just aListener
) -
The
on
andonce
methods ofNotifier
now return anNotificationListener
(instead of just aListener
) -
The
on
andonce
methods ofNSObject
now return anChangeListener<T>
(instead of just aListener
) -
The
keyPath
,options
, andobject
properties ofChangeListener<T>
are now public. -
A
listenerCount: Int
computed property was added to theEvent<T>
class. -
An
event: Event<T>
property was added to theEventListener<T>
class.
The changelog for older versions can be found here.