Use the iterator design for bytes based API as well

tools/rsync/api.go

@@ -187,18 +187,26 @@ func (self *Patcher) CreateSignature(src io.Reader, callback func([]byte) error)
 	})
 }
 
+type DeltaIterator = func() ([]byte, error)
+
 // Create a serialized delta based on the previously loaded signature
-func (self *Differ) CreateDelta(src io.Reader, output_callback func([]byte) error) (err error) {
-	if err = self.finish_signature_data(); err != nil {
-		return
+func (self *Differ) CreateDelta(src io.Reader) DeltaIterator {
+	if err := self.finish_signature_data(); err != nil {
+		return func() ([]byte, error) { return nil, err }
 	}
 	if self.signature == nil {
-		return fmt.Errorf("Cannot call CreateDelta() before loading a signature")
+		return func() ([]byte, error) { return nil, fmt.Errorf("Cannot call CreateDelta() before loading a signature") }
+	}
+	it := self.rsync.CreateDiff(src, self.signature)
+	return func() ([]byte, error) {
+		for {
+			op, err := it()
+			if op == nil {
+				return nil, err
+			}
+			return op.Serialize(), nil
+		}
 	}
-	self.rsync.CreateDelta(src, self.signature, func(op Operation) error {
-		return output_callback(op.Serialize())
-	})
-	return
 }
 
 // Add more external signature data

tools/rsync/api_test.go

@@ -81,8 +81,16 @@ func run_roundtrip_test(t *testing.T, src_data, changed []byte, num_of_patches,
 		t.Fatal(err)
 	}
 	deltabuf := bytes.Buffer{}
-	if err := d.CreateDelta(bytes.NewReader(src_data), func(b []byte) error { _, err := deltabuf.Write(b); return err }); err != nil {
-		t.Fatal(err)
+	it := d.CreateDelta(bytes.NewBuffer(src_data))
+	for {
+		b, err := it()
+		if b == nil {
+			if err != nil {
+				t.Fatal(err)
+			}
+			break
+		}
+		deltabuf.Write(b)
 	}
 	outputbuf := bytes.Buffer{}
 	p.StartDelta(&outputbuf, bytes.NewReader(src_data))