notifier

package
v1.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jan 11, 2021 License: Apache-2.0, MIT Imports: 3 Imported by: 0

Documentation

Overview

Package notifier provides a simple notification dispatcher meant to be embedded in larger structures 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
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL