add MessageHandler interface

Author: briansorahan

dispatcher.go

@@ -15,8 +15,18 @@ var (
 // Method is an OSC method
 type Method func(msg Message) error
 
+// Handle handles an OSC message.
+func (method Method) Handle(m Message) error {
+	return method(m)
+}
+
+// MessageHandler is any type that can handle an OSC message.
+type MessageHandler interface {
+	Handle(Message) error
+}
+
 // Dispatcher dispatches OSC packets.
-type Dispatcher map[string]Method
+type Dispatcher map[string]MessageHandler
 
 // Dispatch invokes an OSC bundle's messages.
 func (d Dispatcher) Dispatch(b Bundle) error {
@@ -60,13 +70,13 @@ func (d Dispatcher) invoke(p Packet) error {
 
 // Invoke invokes an OSC message.
 func (d Dispatcher) Invoke(msg Message) error {
-	for address, method := range d {
+	for address, handler := range d {
 		matched, err := msg.Match(address)
 		if err != nil {
 			return err
 		}
 		if matched {
-			return method(msg)
+			return handler.Handle(msg)
 		}
 	}
 	return nil

dispatcher_test.go

@@ -11,10 +11,10 @@ import (
 func TestDispatcherDispatchOK(t *testing.T) {
 	c := make(chan struct{})
 	d := Dispatcher{
-		"/bar": func(msg Message) error {
+		"/bar": Method(func(msg Message) error {
 			close(c)
 			return nil
-		},
+		}),
 	}
 	later := time.Now().Add(20 * time.Millisecond)
 	b := Bundle{
@@ -32,9 +32,9 @@ func TestDispatcherDispatchOK(t *testing.T) {
 // Test a method that returns an error.
 func TestDispatcherDispatchError(t *testing.T) {
 	d := Dispatcher{
-		"/foo": func(msg Message) error {
+		"/foo": Method(func(msg Message) error {
 			return errors.New("oops")
-		},
+		}),
 	}
 	later := time.Now().Add(20 * time.Millisecond)
 	b := Bundle{
@@ -51,10 +51,10 @@ func TestDispatcherDispatchError(t *testing.T) {
 func TestDispatcherDispatchNestedBundle(t *testing.T) {
 	c := make(chan struct{})
 	d := Dispatcher{
-		"/foo": func(msg Message) error {
+		"/foo": Method(func(msg Message) error {
 			close(c)
 			return nil
-		},
+		}),
 	}
 	later := time.Now().Add(20 * time.Millisecond)
 	b := Bundle{
@@ -76,9 +76,9 @@ func TestDispatcherDispatchNestedBundle(t *testing.T) {
 
 func TestDispatcherMiss(t *testing.T) {
 	d := Dispatcher{
-		"/foo": func(msg Message) error {
+		"/foo": Method(func(msg Message) error {
 			return nil
-		},
+		}),
 	}
 	b := Bundle{
 		Timetag: FromTime(time.Now()),
@@ -90,12 +90,12 @@ func TestDispatcherMiss(t *testing.T) {
 
 func TestDispatcherInvoke(t *testing.T) {
 	d := Dispatcher{
-		"/foo": func(msg Message) error {
+		"/foo": Method(func(msg Message) error {
 			return errors.New("foo error")
-		},
-		"/bar": func(msg Message) error {
+		}),
+		"/bar": Method(func(msg Message) error {
 			return nil
-		},
+		}),
 	}
 	msg := Message{Address: "/foo"}
 	if err := d.Invoke(msg); err == nil {

udp_example_test.go

@@ -67,33 +67,33 @@ func ExampleUDPConn_pingpong() {
 
 func serverDispatch(server *UDPConn, errChan chan error) {
 	errChan <- server.Serve(Dispatcher{
-		"/ping": func(msg Message) error {
+		"/ping": Method(func(msg Message) error {
 			fmt.Println("Server received ping.")
 			return server.SendTo(msg.Sender, Message{Address: "/pong"})
-		},
-		"/close": func(msg Message) error {
+		}),
+		"/close": Method(func(msg Message) error {
 			if err := server.SendTo(msg.Sender, Message{Address: "/close"}); err != nil {
 				_ = server.Close()
 				return err
 			}
 			fmt.Println("Server closing.")
 			return server.Close()
-		},
+		}),
 	})
 }
 
 func clientDispatch(client *UDPConn, errChan chan error, pongChan chan struct{}, closeChan chan struct{}) {
 	errChan <- client.Serve(Dispatcher{
-		"/pong": func(msg Message) error {
+		"/pong": Method(func(msg Message) error {
 			fmt.Println("Client received pong.")
 			close(pongChan)
 			return nil
-		},
-		"/close": func(msg Message) error {
+		}),
+		"/close": Method(func(msg Message) error {
 			fmt.Println("Client closing.")
 			close(closeChan)
 			return client.Close()
-		},
+		}),
 	})
 }
 

udp_test.go

@@ -21,10 +21,10 @@ func TestInvalidAddress(t *testing.T) {
 	}
 	defer func() { _ = server.Close() }() // Best effort.
 
-	if err := server.Serve(map[string]Method{
-		"/[": func(msg Message) error {
+	if err := server.Serve(Dispatcher{
+		"/[": Method(func(msg Message) error {
 			return nil
-		},
+		}),
 	}); err != ErrInvalidAddress {
 		t.Fatal("expected invalid address error")
 	}
@@ -95,9 +95,9 @@ func testUDPServer(t *testing.T, dispatcher Dispatcher) (*UDPConn, *UDPConn, cha
 	if dispatcher == nil {
 		dispatcher = Dispatcher{}
 	}
-	dispatcher["/server/close"] = func(msg Message) error {
+	dispatcher["/server/close"] = Method(func(msg Message) error {
 		return server.Close()
-	}
+	})
 	errChan := make(chan error)
 
 	go func() {
@@ -180,10 +180,10 @@ func TestUDPConnServe_ReadError(t *testing.T) {
 		ctx:     context.Background(),
 	}
 	go func() {
-		errChan <- server.Serve(map[string]Method{
-			"/close": func(msg Message) error {
+		errChan <- server.Serve(Dispatcher{
+			"/close": Method(func(msg Message) error {
 				return server.Close()
-			},
+			}),
 		})
 	}()
 
@@ -227,9 +227,9 @@ func TestUDPConnServe_BadInboundAddr(t *testing.T) {
 	} {
 		// Send a message with a bad address.
 		_, conn, errChan := testUDPServer(t, Dispatcher{
-			"/foo": func(msg Message) error {
+			"/foo": Method(func(msg Message) error {
 				return nil
-			},
+			}),
 		})
 		if err := conn.Send(packet); err != nil {
 			t.Fatal(err)
@@ -297,9 +297,9 @@ func TestUDPConnSendBundle_DispatchError(t *testing.T) {
 		},
 	}
 	_, conn, errChan := testUDPServer(t, Dispatcher{
-		"/foo": func(msg Message) error {
+		"/foo": Method(func(msg Message) error {
 			return errors.New("oops")
-		},
+		}),
 	})
 	if err := conn.Send(b); err != nil {
 		t.Fatal(err)