energylink/pkg/bus/bus.go

package bus

import (
	"errors"
	"reflect"
)

type HandlerFunc interface{}
type Msg interface{}

type Bus interface {
	Dispatch(msg Msg) error
	Publish(msg Msg) error
	AddHandler(handler HandlerFunc)
	AddEventListener(handler HandlerFunc)
}

type InProcBus struct {
	handlers  map[string]HandlerFunc
	listeners map[string][]HandlerFunc
}

// temp stuff, not sure how to handle bus instance, and init yet
var globalBus = New()

func New() Bus {
	bus := &InProcBus{}
	bus.handlers = make(map[string]HandlerFunc)
	bus.listeners = make(map[string][]HandlerFunc)
	return bus
}

func (b *InProcBus) Dispatch(msg Msg) error {
	var msgName = reflect.TypeOf(msg).Elem().Name()

	var handler = b.handlers[msgName]
	if handler == nil {
		return errors.New("handler not found")
	}

	var params = make([]reflect.Value, 1)
	params[0] = reflect.ValueOf(msg)

	ret := reflect.ValueOf(handler).Call(params)
	err := ret[0].Interface()
	if err == nil {
		return nil
	} else {
		return err.(error)
	}
}

func (b *InProcBus) Publish(msg Msg) error {
	var msgName = reflect.TypeOf(msg).Elem().Name()

	var listeners = b.listeners[msgName]
	if len(listeners) == 0 {
		return nil
	}

	var params = make([]reflect.Value, 1)
	params[0] = reflect.ValueOf(msg)

	for listenerHandler := range listeners {
		ret := reflect.ValueOf(listenerHandler).Call(params)
		err := ret[0].Interface()
		if err != nil {
			return err.(error)
		}
	}

	return nil
}

func (b *InProcBus) AddHandler(handler HandlerFunc) {
	handlerType := reflect.TypeOf(handler)
	queryTypeName := handlerType.In(0).Elem().Name()
	b.handlers[queryTypeName] = handler
}

func (b *InProcBus) AddEventListener(handler HandlerFunc) {
	handlerType := reflect.TypeOf(handler)
	eventName := handlerType.In(0).Elem().Name()
	list, exists := b.listeners[eventName]
	if !exists {
		list = make([]HandlerFunc, 0)
		b.listeners[eventName] = list
	}
	list = append(list, handler)
}

// Package level functions
func AddHandler(implName string, handler HandlerFunc) {
	globalBus.AddHandler(handler)
}

// Package level functions
func AddEventListener(handler HandlerFunc) {
	globalBus.AddEventListener(handler)
}

func Dispatch(msg Msg) error {
	return globalBus.Dispatch(msg)
}