netchan: allow chan of basic types now that gob can handle such

R=rsc
CC=golang-dev
https://golang.org/cl/1741041

diff --git a/src/pkg/netchan/export.go b/src/pkg/netchan/export.go
index ea1d63fb9e3d923f05a3e2c045e37f69a883e769..203741cd71f1020e3cda61ba61b301e925611dd9 100644 (file)
--- a/src/pkg/netchan/export.go
+++ b/src/pkg/netchan/export.go
@@ -225,7 +225,7 @@ func checkChan(chT interface{}, dir Dir) (*reflect.ChanValue, os.Error) {
 // Despite the literal signature, the effective signature is
 //     Export(name string, chT chan T, dir Dir)
 // where T must be a struct, pointer to struct, etc.
-// TODO: fix gob interface so we can eliminate the need for pT, and for structs.
+// TODO: fix reflection so we can eliminate the need for pT.
 func (exp *Exporter) Export(name string, chT interface{}, dir Dir, pT interface{}) os.Error {
        ch, err := checkChan(chT, dir)
        if err != nil {

diff --git a/src/pkg/netchan/import.go b/src/pkg/netchan/import.go
index 454e265b217cfbdae559d3037baae09baed406fb..d2fd23473c79748faf700edbca3c0e6621f02493 100644 (file)
--- a/src/pkg/netchan/import.go
+++ b/src/pkg/netchan/import.go
@@ -136,7 +136,7 @@ func (imp *Importer) Import(name string, chT interface{}, dir Dir, pT interface{
 //     err := imp.ImportNValues("name", ch, Recv, new(myType), 1)
 //     if err != nil { log.Exit(err) }
 //     fmt.Printf("%+v\n", <-ch)
-// TODO: fix gob interface so we can eliminate the need for pT, and for structs.
+// TODO: fix reflection so we can eliminate the need for pT.
 func (imp *Importer) ImportNValues(name string, chT interface{}, dir Dir, pT interface{}, n int) os.Error {
        ch, err := checkChan(chT, dir)
        if err != nil {
@@ -147,9 +147,6 @@ func (imp *Importer) ImportNValues(name string, chT interface{}, dir Dir, pT int
        if _, ok := rt.(*reflect.PtrType); !ok {
                return os.ErrorString("not a pointer:" + rt.String())
        }
-       if _, ok := reflect.Indirect(reflect.NewValue(pT)).(*reflect.StructValue); !ok {
-               return os.ErrorString("not a pointer to a struct:" + rt.String())
-       }
        imp.chanLock.Lock()
        defer imp.chanLock.Unlock()
        _, present := imp.chans[name]

diff --git a/src/pkg/netchan/netchan_test.go b/src/pkg/netchan/netchan_test.go
index 01fc0f32726811ffa799359794af61e7ccd0194c..98799be91edc68cb891d54e41696b4bc522a81a7 100644 (file)
--- a/src/pkg/netchan/netchan_test.go
+++ b/src/pkg/netchan/netchan_test.go
@@ -6,43 +6,38 @@ package netchan
 
 import "testing"
 
-type value struct {
-       i int
-       s string
-}
-
 const count = 10     // number of items in most tests
 const closeCount = 5 // number of items when sender closes early
 
 func exportSend(exp *Exporter, n int, t *testing.T) {
-       ch := make(chan value)
-       err := exp.Export("exportedSend", ch, Send, new(value))
+       ch := make(chan int)
+       err := exp.Export("exportedSend", ch, Send, new(int))
        if err != nil {
                t.Fatal("exportSend:", err)
        }
        for i := 0; i < n; i++ {
-               ch <- value{23 + i, "hello"}
+               ch <- 23+i
        }
        close(ch)
 }
 
 func exportReceive(exp *Exporter, t *testing.T) {
-       ch := make(chan value)
-       err := exp.Export("exportedRecv", ch, Recv, new(value))
+       ch := make(chan int)
+       err := exp.Export("exportedRecv", ch, Recv, new(int))
        if err != nil {
                t.Fatal("exportReceive:", err)
        }
        for i := 0; i < count; i++ {
                v := <-ch
-               if v.i != 45+i || v.s != "hello" {
-                       t.Errorf("export Receive: bad value: expected 4%d, hello; got %+v", 45+i, v)
+               if v != 45+i {
+                       t.Errorf("export Receive: bad value: expected 4%d; got %d", 45+i, v)
                }
        }
 }
 
 func importReceive(imp *Importer, t *testing.T) {
-       ch := make(chan value)
-       err := imp.ImportNValues("exportedSend", ch, Recv, new(value), count)
+       ch := make(chan int)
+       err := imp.ImportNValues("exportedSend", ch, Recv, new(int), count)
        if err != nil {
                t.Fatal("importReceive:", err)
        }
@@ -54,20 +49,20 @@ func importReceive(imp *Importer, t *testing.T) {
                        }
                        break
                }
-               if v.i != 23+i || v.s != "hello" {
-                       t.Errorf("importReceive: bad value: expected %d, hello; got %+v", 23+i, v)
+               if v != 23+i {
+                       t.Errorf("importReceive: bad value: expected %d; got %+d", 23+i, v)
                }
        }
 }
 
 func importSend(imp *Importer, t *testing.T) {
-       ch := make(chan value)
-       err := imp.ImportNValues("exportedRecv", ch, Send, new(value), count)
+       ch := make(chan int)
+       err := imp.ImportNValues("exportedRecv", ch, Send, new(int), count)
        if err != nil {
                t.Fatal("importSend:", err)
        }
        for i := 0; i < count; i++ {
-               ch <- value{45 + i, "hello"}
+               ch <- 45+i
        }
 }