Marshaller and finished Endpoint example

Author: oxzi

examples/endpoint/0doc.go

@@ -0,0 +1,3 @@
+// Package endpoint contains a simplified version of the EndpointID struct from
+// the dtn7-go <https://github.com/dtn7/dtn7-go> application.
+package endpoint

examples/endpoint/endpoint.go

@@ -1,4 +1,4 @@
-package main
+package endpoint
 
 import (
 	"fmt"
@@ -12,39 +12,39 @@ const (
 	endpointURISchemeIPN uint64 = 2
 )
 
-type EndpointID struct {
+type endpointID struct {
 	SchemeName         uint64
 	SchemeSpecificPart interface{}
 }
 
-func newEndpointIDDTN(ssp string) EndpointID {
+func newEndpointIDDTN(ssp string) endpointID {
 	var sspRaw interface{}
 	if ssp == "none" {
 		sspRaw = uint64(0)
 	} else {
 		sspRaw = string(ssp)
 	}
 
-	return EndpointID{
+	return endpointID{
 		SchemeName:         endpointURISchemeDTN,
 		SchemeSpecificPart: sspRaw,
 	}
 }
 
-func newEndpointIDIPN(ssp string) EndpointID {
+func newEndpointIDIPN(ssp string) endpointID {
 	re := regexp.MustCompile(`^(\d+)\.(\d+)$`)
 	matches := re.FindStringSubmatch(ssp)
 
 	nodeNo, _ := strconv.ParseUint(matches[1], 10, 64)
 	serviceNo, _ := strconv.ParseUint(matches[2], 10, 64)
 
-	return EndpointID{
+	return endpointID{
 		SchemeName:         endpointURISchemeIPN,
 		SchemeSpecificPart: [2]uint64{nodeNo, serviceNo},
 	}
 }
 
-func NewEndpointID(eid string) EndpointID {
+func newEndpointID(eid string) endpointID {
 	re := regexp.MustCompile(`^([[:alnum:]]+):(.+)$`)
 	matches := re.FindStringSubmatch(eid)
 
@@ -57,11 +57,11 @@ func NewEndpointID(eid string) EndpointID {
 	case "ipn":
 		return newEndpointIDIPN(ssp)
 	default:
-		return EndpointID{}
+		return endpointID{}
 	}
 }
 
-func (eid EndpointID) String() string {
+func (eid endpointID) String() string {
 	var b strings.Builder
 
 	switch eid.SchemeName {

examples/endpoint/endpoint_cbor.go

@@ -1,12 +1,13 @@
-package main
+package endpoint
 
 import (
+	"fmt"
 	"io"
 
 	"github.com/dtn7/cboring"
 )
 
-func (eid *EndpointID) MarshalCbor(w io.Writer) error {
+func (eid *endpointID) MarshalCbor(w io.Writer) error {
 	// Start an array with two elements
 	if err := cboring.WriteArrayLength(2, w); err != nil {
 		return err
@@ -48,7 +49,56 @@ func (eid *EndpointID) MarshalCbor(w io.Writer) error {
 	return nil
 }
 
-func (eid *EndpointID) UnmarshalCbor(r io.Reader) error {
-	// TODO
+func (eid *endpointID) UnmarshalCbor(r io.Reader) error {
+	// Start of an array with two elements
+	if l, err := cboring.ReadArrayLength(r); err != nil {
+		return err
+	} else if l != 2 {
+		return fmt.Errorf("Expected array with length 2, got %d", l)
+	}
+
+	// URI code: scheme name
+	if sn, err := cboring.ReadUInt(r); err != nil {
+		return err
+	} else {
+		eid.SchemeName = sn
+	}
+
+	// SSP
+	if m, n, err := cboring.ReadMajors(r); err != nil {
+		return err
+	} else {
+		switch m {
+		case cboring.UInt:
+			// dtn:none
+			eid.SchemeSpecificPart = n
+
+		case cboring.TextString:
+			// dtn:whatsoever
+			if tmp, err := cboring.ReadRawBytes(n, r); err != nil {
+				return err
+			} else {
+				eid.SchemeSpecificPart = string(tmp)
+			}
+
+		case cboring.Array:
+			// ipn:23.42
+			if n != 2 {
+				return fmt.Errorf("Expected array with length 2, got %d", n)
+			}
+
+			var ssps [2]uint64
+			for i := 0; i < 2; i++ {
+				if n, err := cboring.ReadUInt(r); err != nil {
+					return err
+				} else {
+					ssps[i] = n
+				}
+			}
+
+			eid.SchemeSpecificPart = ssps
+		}
+	}
+
 	return nil
 }

examples/endpoint/endpoint_test.go

@@ -0,0 +1,73 @@
+package endpoint
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/dtn7/cboring"
+)
+
+var endpointTests = []struct {
+	eid  string
+	cbor []byte
+}{
+	{"dtn:none", []byte{0x82, 0x01, 0x00}},
+	{"dtn:foo", []byte{0x82, 0x01, 0x63, 0x66, 0x6F, 0x6F}},
+	{"dtn:foo/bar", []byte{0x82, 0x01, 0x67, 0x66, 0x6F, 0x6F, 0x2F, 0x62, 0x61, 0x72}},
+	{"ipn:0.0", []byte{0x82, 0x02, 0x82, 0x00, 0x00}},
+	{"ipn:23.42", []byte{0x82, 0x02, 0x82, 0x17, 0x18, 0x2A}},
+}
+
+func TestEndpoint(t *testing.T) {
+	for _, test := range endpointTests {
+		t.Run(fmt.Sprintf("marshal-%s", test.eid), func(t *testing.T) {
+			e := newEndpointID(test.eid)
+
+			buff := new(bytes.Buffer)
+			if err := cboring.Marshal(&e, buff); err != nil {
+				t.Fatalf("Marshaling %s failed: %v", test.eid, err)
+			}
+
+			if data := buff.Bytes(); !reflect.DeepEqual(data, test.cbor) {
+				t.Fatalf("CBOR differs: %x != %x", data, test.cbor)
+			}
+		})
+
+		t.Run(fmt.Sprintf("unmarshal-%s", test.eid), func(t *testing.T) {
+			e := endpointID{}
+
+			buff := bytes.NewBuffer(test.cbor)
+			if err := cboring.Unmarshal(&e, buff); err != nil {
+				t.Fatalf("Unmarshaling %s failed: %v", test.eid, err)
+			}
+
+			if e.String() != test.eid {
+				t.Fatalf("EID differs: %s != %s", e.String(), test.eid)
+			}
+		})
+	}
+}
+
+func BenchmarkEndpoint(b *testing.B) {
+	for _, test := range endpointTests {
+		b.Run(fmt.Sprintf("marshal-%s", test.eid), func(b *testing.B) {
+			e := newEndpointID(test.eid)
+
+			buff := new(bytes.Buffer)
+			if err := cboring.Marshal(&e, buff); err != nil {
+				b.Fatalf("Marshaling %s failed: %v", test.eid, err)
+			}
+		})
+
+		b.Run(fmt.Sprintf("unmarshal-%s", test.eid), func(b *testing.B) {
+			e := endpointID{}
+
+			buff := bytes.NewBuffer(test.cbor)
+			if err := cboring.Unmarshal(&e, buff); err != nil {
+				b.Fatalf("Unmarshaling %s failed: %v", test.eid, err)
+			}
+		})
+	}
+}

examples/endpoint/main.go

@@ -2,16 +2,19 @@ package cboring
 
 import "io"
 
+// CborMarshaler is the interface implemented by an object that can both marshal
+// itself into a CBOR form and unmarshal a CBOR representation of itself.
 type CborMarshaler interface {
 	MarshalCbor(w io.Writer) error
 	UnmarshalCbor(r io.Reader) error
 }
 
-/*
+// Marshal writes a CBOR representation of a CborMarshaler into the Writer.
 func Marshal(data CborMarshaler, w io.Writer) error {
-
+	return data.MarshalCbor(w)
 }
 
+// Unmarshal reads a CBOR representation from a Reader into a CborMarshaler.
 func Unmarshal(data CborMarshaler, r io.Reader) error {
+	return data.UnmarshalCbor(r)
 }
-*/

marshal.go

@@ -5,13 +5,10 @@ import (
 	"io"
 )
 
-func readString(len int, r io.Reader) (data []byte, err error) {
-	data = make([]byte, len)
-	if rn, rerr := io.ReadFull(r, data); err != nil {
-		err = rerr
-	} else if rn != len {
-		err = fmt.Errorf("readString: read length mismatches: %d != %d", rn, len)
-	}
+// ReadRawBytes reads the next l bytes from r into a new byte slice.
+func ReadRawBytes(l uint64, r io.Reader) (data []byte, err error) {
+	data = make([]byte, l)
+	_, err = io.ReadFull(r, data)
 	return
 }
 
@@ -23,7 +20,7 @@ func ReadByteString(r io.Reader) (data []byte, err error) {
 		return
 	}
 
-	return readString(int(n), r)
+	return ReadRawBytes(n, r)
 }
 
 // WriteByteString writes a byte string into the Writer.
@@ -49,7 +46,7 @@ func ReadTextString(r io.Reader) (data string, err error) {
 		return
 	}
 
-	if rdata, rerr := readString(int(n), r); rerr != nil {
+	if rdata, rerr := ReadRawBytes(n, r); rerr != nil {
 		err = rerr
 	} else {
 		data = string(rdata)