Documentation
¶
Overview ¶
Package notifier provides a simple notification dispatcher meant to be embedded in larger structres who wish to allow clients to sign up for event notifications.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Notifiee ¶
type Notifiee interface{}
Notifiee is a generic interface. Clients implement their own Notifiee interfaces to ensure type-safety of notifications:
type RocketNotifiee interface{
Countdown(r Rocket, countdown time.Duration)
LiftedOff(Rocket)
ReachedOrbit(Rocket)
Detached(Rocket, Capsule)
Landed(Rocket)
}
type Notifier ¶
type Notifier struct {
// contains filtered or unexported fields
}
Notifier is a notification dispatcher. It's meant to be composed, and its zero-value is ready to be used.
type Rocket struct {
notifier notifier.Notifier
}
func RateLimited ¶
func RateLimited(limit int) Notifier
RateLimited returns a rate limited Notifier. only limit goroutines will be spawned. If limit is zero, no rate limiting happens. This is the same as `Notifier{}`.
func (*Notifier) Notify ¶
func (n *Notifier) Notify(e Notifiee)
Notify signs up Notifiee e for notifications. This function is meant to be called behind your own type-safe function(s):
// generic function for pattern-following
func (r *Rocket) Notify(n Notifiee) {
r.notifier.Notify(n)
}
// or as part of other functions
func (r *Rocket) Onboard(a Astronaut) {
r.astronauts = append(r.austronauts, a)
r.notifier.Notify(a)
}
func (*Notifier) NotifyAll ¶
func (n *Notifier) NotifyAll(notify func(Notifiee))
NotifyAll messages the notifier's notifiees with a given notification. This is done by calling the given function with each notifiee. It is meant to be called with your own type-safe notification functions:
func (r *Rocket) Launch() {
r.notifyAll(func(n Notifiee) {
n.Launched(r)
})
}
// make it private so only you can use it. This function is necessary
// to make sure you only up-cast in one place. You control who you added
// to be a notifiee. If Go adds generics, maybe we can get rid of this
// method but for now it is like wrapping a type-less container with
// a type safe interface.
func (r *Rocket) notifyAll(notify func(Notifiee)) {
r.notifier.NotifyAll(func(n notifier.Notifiee) {
notify(n.(Notifiee))
})
}
Note well: each notification is launched in its own goroutine, so they can be processed concurrently, and so that whatever the notification does it _never_ blocks out the client. This is so that consumers _cannot_ add hooks into your object that block you accidentally.
func (*Notifier) StopNotify ¶
func (n *Notifier) StopNotify(e Notifiee)
StopNotify stops notifying Notifiee e. This function is meant to be called behind your own type-safe function(s):
// generic function for pattern-following
func (r *Rocket) StopNotify(n Notifiee) {
r.notifier.StopNotify(n)
}
// or as part of other functions
func (r *Rocket) Detach(c Capsule) {
r.notifier.StopNotify(c)
r.capsule = nil
}
Source Files