mirror of https://github.com/fluffle/goirc
141 lines
2.7 KiB
Go
141 lines
2.7 KiB
Go
package event
|
|
|
|
import (
|
|
"container/list"
|
|
"strings"
|
|
"sync/atomic"
|
|
"sync"
|
|
)
|
|
|
|
type HandlerID uint32
|
|
|
|
var hidCounter uint32 = 0
|
|
|
|
func NewHandlerID() HandlerID {
|
|
return HandlerID(atomic.AddUint32(&hidCounter, 1))
|
|
}
|
|
|
|
type Handler interface {
|
|
Run(...interface{})
|
|
Id() HandlerID
|
|
}
|
|
|
|
type basicHandler struct {
|
|
fn func(...interface{})
|
|
id HandlerID
|
|
}
|
|
|
|
func (h *basicHandler) Run(ev ...interface{}) {
|
|
h.fn(ev...)
|
|
}
|
|
|
|
func (h *basicHandler) Id() HandlerID {
|
|
return h.id
|
|
}
|
|
|
|
func NewHandler(h func(...interface{})) Handler {
|
|
return &basicHandler{h, NewHandlerID()}
|
|
}
|
|
|
|
type EventDispatcher interface {
|
|
Dispatch(name string, ev ...interface{})
|
|
}
|
|
|
|
type EventRegistry interface {
|
|
AddHandler(name string, h Handler)
|
|
DelHandler(h Handler)
|
|
Dispatch(name string, ev ...interface{})
|
|
ClearEvents(name string)
|
|
}
|
|
|
|
type registry struct {
|
|
// Event registry as a lockable map of linked-lists
|
|
sync.RWMutex
|
|
events map[string]*list.List
|
|
dispatcher func(r *registry, name string, ev ...interface{})
|
|
}
|
|
|
|
func NewRegistry() EventRegistry {
|
|
r := ®istry{events: make(map[string]*list.List)}
|
|
r.Parallel()
|
|
return r
|
|
}
|
|
|
|
func (r *registry) AddHandler(name string, h Handler) {
|
|
name = strings.ToLower(name)
|
|
r.Lock()
|
|
defer r.Unlock()
|
|
if _, ok := r.events[name]; !ok {
|
|
r.events[name] = list.New()
|
|
}
|
|
for e := r.events[name].Front(); e != nil; e = e.Next() {
|
|
// Check we're not adding a duplicate handler to this event
|
|
if e.Value.(Handler).Id() == h.Id() {
|
|
return
|
|
}
|
|
}
|
|
r.events[name].PushBack(h)
|
|
}
|
|
|
|
func (r *registry) DelHandler(h Handler) {
|
|
// This is a bit brute-force. Don't add too many handlers!
|
|
r.Lock()
|
|
defer r.Unlock()
|
|
for _, l := range r.events {
|
|
for e := l.Front(); e != nil; e = e.Next() {
|
|
if e.Value.(Handler).Id() == h.Id() {
|
|
l.Remove(e)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *registry) Dispatch(name string, ev ...interface{}) {
|
|
r.dispatcher(r, name, ev...)
|
|
}
|
|
|
|
func (r *registry) ClearEvents(name string) {
|
|
r.Lock()
|
|
defer r.Unlock()
|
|
if l, ok := r.events[name]; ok {
|
|
l.Init()
|
|
}
|
|
}
|
|
|
|
func (r *registry) Parallel() {
|
|
r.dispatcher = (*registry).parallelDispatch
|
|
}
|
|
|
|
func (r *registry) Serial() {
|
|
r.dispatcher = (*registry).serialDispatch
|
|
}
|
|
|
|
func (r *registry) parallelDispatch(name string, ev ...interface{}) {
|
|
name = strings.ToLower(name)
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
if l, ok := r.events[name]; ok {
|
|
for e := l.Front(); e != nil; e = e.Next() {
|
|
h := e.Value.(Handler)
|
|
go h.Run(ev...)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *registry) serialDispatch(name string, ev ...interface{}) {
|
|
name = strings.ToLower(name)
|
|
r.RLock()
|
|
defer r.RUnlock()
|
|
if l, ok := r.events[name]; ok {
|
|
hlist := make([]Handler, 0, l.Len())
|
|
for e := l.Front(); e != nil; e = e.Next() {
|
|
hlist = append(hlist, e.Value.(Handler))
|
|
}
|
|
go func() {
|
|
for _, h := range hlist {
|
|
h.Run(ev...)
|
|
}
|
|
}()
|
|
}
|
|
}
|