Switch everything over to use our own DataFrame

signals.go

@@ -3,60 +3,68 @@ package autotrader
 import "reflect"
 
 type Signaler interface {
-	SignalConnect(signal string, handler func(interface{})) error  // SignalConnect connects the handler to the signal.
-	SignalConnected(signal string, handler func(interface{})) bool // SignalConnected returns true if the handler is connected to the signal.
-	SignalConnections(signal string) []func(interface{})           // SignalConnections returns a slice of handlers connected to the signal.
-	SignalDisconnect(signal string, handler func(interface{}))     // SignalDisconnect removes the handler from the signal.
-	SignalEmit(signal string, data interface{})                    // SignalEmit emits the signal with the data.
+	SignalConnect(signal string, handler func(...interface{}), bindings ...interface{}) error // SignalConnect connects the handler to the signal.
+	SignalConnected(signal string, handler func(...interface{})) bool                         // SignalConnected returns true if the handler is connected to the signal.
+	SignalConnections(signal string) []SignalHandler                                          // SignalConnections returns a slice of handlers connected to the signal.
+	SignalDisconnect(signal string, handler func(...interface{}))                             // SignalDisconnect removes the handler from the signal.
+	SignalEmit(signal string, data ...interface{})                                            // SignalEmit emits the signal with the data.
+}
+
+type SignalHandler struct {
+	Callback func(...interface{})
+	Bindings []interface{}
 }
 
 type SignalManager struct {
-	signalConnections map[string][]func(interface{})
+	signalConnections map[string][]SignalHandler
 }
 
-func (s *SignalManager) SignalConnect(signal string, handler func(interface{})) error {
+func (s *SignalManager) SignalConnect(signal string, callback func(...interface{}), bindings ...interface{}) error {
 	if s.signalConnections == nil {
-		s.signalConnections = make(map[string][]func(interface{}))
+		s.signalConnections = make(map[string][]SignalHandler)
 	}
-	s.signalConnections[signal] = append(s.signalConnections[signal], handler)
+	s.signalConnections[signal] = append(s.signalConnections[signal], SignalHandler{callback, bindings})
 	return nil
 }
 
-func (s *SignalManager) SignalConnected(signal string, handler func(interface{})) bool {
+func (s *SignalManager) SignalConnected(signal string, callback func(...interface{})) bool {
 	if s.signalConnections == nil {
 		return false
 	}
 	for _, h := range s.signalConnections[signal] {
-		if reflect.ValueOf(h).Pointer() == reflect.ValueOf(handler).Pointer() {
+		if reflect.ValueOf(h.Callback).Pointer() == reflect.ValueOf(callback).Pointer() {
 			return true
 		}
 	}
 	return false
 }
 
-func (s *SignalManager) SignalConnections(signal string) []func(interface{}) {
+func (s *SignalManager) SignalConnections(signal string) []SignalHandler {
 	if s.signalConnections == nil {
 		return nil
 	}
 	return s.signalConnections[signal]
 }
 
-func (s *SignalManager) SignalDisconnect(signal string, handler func(interface{})) {
+func (s *SignalManager) SignalDisconnect(signal string, callback func(...interface{})) {
 	if s.signalConnections == nil {
 		return
 	}
 	for i, h := range s.signalConnections[signal] {
-		if reflect.ValueOf(h).Pointer() == reflect.ValueOf(handler).Pointer() {
+		if reflect.ValueOf(h.Callback).Pointer() == reflect.ValueOf(callback).Pointer() {
 			s.signalConnections[signal] = append(s.signalConnections[signal][:i], s.signalConnections[signal][i+1:]...)
 		}
 	}
 }
 
-func (s *SignalManager) SignalEmit(signal string, data interface{}) {
+func (s *SignalManager) SignalEmit(signal string, data ...interface{}) {
 	if s.signalConnections == nil {
 		return
 	}
 	for _, handler := range s.signalConnections[signal] {
-		handler(data)
+		args := make([]interface{}, len(data)+len(handler.Bindings))
+		copy(args, data)
+		copy(args[len(data):], handler.Bindings)
+		handler.Callback(args...)
 	}
 }