add Synths methods to Client to more efficiently create multiple synths at a single time

Author: briansorahan

c.go

@@ -3,6 +3,7 @@ package sc
 // C wraps a float32 and implements the Input interface.
 type C float32
 
+// Max returns the maximum of one input and another.
 func (c C) Max(other Input) Input {
 	if v, ok := other.(C); ok {
 		return C(maxFloat32(float32(c), float32(v)))

client.go

@@ -280,6 +280,39 @@ func (c *Client) Synth(defName string, id, action, target int32, ctls map[string
 	return newSynth(c, defName, id), nil
 }
 
+// SynthArgs contains the arguments necessary to create a synth that is part of a group.
+type SynthArgs struct {
+	DefName string
+	ID      int32
+	Action  int32
+	Target  int32
+	Ctls    map[string]float32
+}
+
+// Synths creates multiple synth nodes at once with an OSC bundle.
+func (c *Client) Synths(args []SynthArgs) error {
+	bun := osc.Bundle{
+		Packets: make([]osc.Packet, len(args)),
+	}
+	for i, arg := range args {
+		msg := osc.Message{
+			Address: synthNewAddress,
+			Arguments: osc.Arguments{
+				osc.String(arg.DefName),
+				osc.Int(arg.ID),
+				osc.Int(arg.Action),
+				osc.Int(arg.Target),
+			},
+		}
+		for k, v := range arg.Ctls {
+			msg.Arguments = append(msg.Arguments, osc.String(k))
+			msg.Arguments = append(msg.Arguments, osc.Float(v))
+		}
+		bun.Packets[i] = msg
+	}
+	return c.oscConn.Send(bun)
+}
+
 // Group creates a group.
 func (c *Client) Group(id, action, target int32) (*Group, error) {
 	msg := osc.Message{

group.go

@@ -31,12 +31,22 @@ func (g *Group) Synth(defName string, id, action int32, ctls map[string]float32)
 	return g.client.Synth(defName, id, action, g.Node.ID, ctls)
 }
 
-// Free frees all the nodes in a group
+// Synths creates multiple synth nodes at once with an OSC bundle.
+func (g *Group) Synths(args []SynthArgs) error {
+	for _, arg := range args {
+		arg.Target = g.Node.ID
+	}
+	return g.client.Synths(args)
+}
+
+// Free frees all the nodes in a group.
+// TODO
 func (g *Group) Free() error {
 	return nil
 }
 
-// FreeAll frees all the nodes in a group recursively
+// FreeAll frees all the nodes in a group recursively.
+// TODO
 func (g *Group) FreeAll() error {
 	return nil
 }

server.go

@@ -91,7 +91,7 @@ func (s *Server) args() ([]string, error) {
 	return args, nil
 }
 
-const ServerReadyMessage = "server ready"
+const serverReadyMessage = "server ready"
 
 // Start starts a new instance of scsynth.
 // If the server doesn't print a line containing ServerReadyMessage
@@ -129,7 +129,7 @@ func (s *Server) Start(timeout time.Duration) (io.ReadCloser, io.ReadCloser, err
 		if time.Now().Sub(start) > timeout {
 			return nil, nil, ErrTimeout
 		}
-		if strings.Index(scanner.Text(), ServerReadyMessage) == -1 {
+		if strings.Index(scanner.Text(), serverReadyMessage) == -1 {
 			continue
 		} else {
 			break