go-ipfs: github.com/ipfs/go-ipfs/thirdparty/notifier Index | Files

package notifier

import "github.com/ipfs/go-ipfs/thirdparty/notifier"

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

Package Files

notifier.go

type Notifiee Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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
}

Package notifier imports 3 packages (graph) and is imported by 13 packages. Updated 2019-03-14. Refresh now. Tools for package owners.