encoding/e?wkb: add *ToHex methods

Author: paulmach

encoding/ewkb/README.md

@@ -8,7 +8,9 @@ The interface is defined as:
 
 ```go
 func Marshal(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) ([]byte, error)
+func MarshalToHex(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) (string, error)
 func MustMarshal(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) []byte
+func MustMarshalToHex(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) string
 
 func NewEncoder(w io.Writer) *Encoder
 func (e *Encoder) SetByteOrder(bo binary.ByteOrder) *Encoder

encoding/ewkb/point_test.go

@@ -47,6 +47,37 @@ func TestPoint(t *testing.T) {
 	}
 }
 
+func TestPointToHex(t *testing.T) {
+	cases := []struct {
+		name     string
+		srid     int
+		data     orb.Point
+		expected string
+	}{
+		{
+			name:     "point",
+			srid:     4326,
+			data:     orb.Point{1, 2},
+			expected: "0101000020e6100000000000000000f03f0000000000000040",
+		},
+		{
+			name:     "zero point",
+			srid:     4,
+			data:     orb.Point{0, 0},
+			expected: "01010000200400000000000000000000000000000000000000",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			s := MustMarshalToHex(tc.data, tc.srid)
+			if s != tc.expected {
+				t.Errorf("incorrect hex: %v", s)
+			}
+		})
+	}
+}
+
 func TestMultiPoint(t *testing.T) {
 	large := orb.MultiPoint{}
 	for i := 0; i < wkbcommon.MaxPointsAlloc+100; i++ {

encoding/ewkb/scanner.go

@@ -73,6 +73,8 @@ func Scanner(g interface{}) *GeometryScanner {
 //	var p orb.Point
 //	err := db.QueryRow("SELECT ST_SRID(latlon), ST_AsBinary(latlon) FROM foo WHERE id=?", id).
 //		Scan(&srid, wkb.Scanner(&p))
+//
+// https://dev.mysql.com/doc/refman/5.7/en/gis-data-formats.html
 func ScannerPrefixSRID(g interface{}) *GeometryScanner {
 	return &GeometryScanner{sridInPrefix: true, g: g}
 }

encoding/ewkb/wkb.go

@@ -3,6 +3,7 @@ package ewkb
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
 	"errors"
 	"io"
 
@@ -71,6 +72,7 @@ func MustMarshal(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) []b
 }
 
 // Marshal encodes the geometry with the given byte order.
+// An SRID of 0 will not be included in the encoding and the result will be a wkb encoding of the geometry.
 func Marshal(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) ([]byte, error) {
 	buf := bytes.NewBuffer(make([]byte, 0, wkbcommon.GeomLength(geom, srid != 0)))
 
@@ -93,6 +95,27 @@ func Marshal(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) ([]byte
 	return buf.Bytes(), nil
 }
 
+// MarshalToHex will encode the geometry into a hex string representation of the binary ewkb.
+func MarshalToHex(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) (string, error) {
+	data, err := Marshal(geom, srid, byteOrder...)
+	if err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(data), nil
+}
+
+// MustMarshalToHex will encode the geometry and panic on error.
+// Currently there is no reason to error during geometry marshalling.
+func MustMarshalToHex(geom orb.Geometry, srid int, byteOrder ...binary.ByteOrder) string {
+	d, err := MarshalToHex(geom, srid, byteOrder...)
+	if err != nil {
+		panic(err)
+	}
+
+	return d
+}
+
 // NewEncoder creates a new Encoder for the given writer.
 func NewEncoder(w io.Writer) *Encoder {
 	e := wkbcommon.NewEncoder(w)

encoding/wkb/README.md

@@ -5,7 +5,9 @@ data. The interface is defined as:
 
 ```go
 func Marshal(geom orb.Geometry, byteOrder ...binary.ByteOrder) ([]byte, error)
+func MarshalToHex(geom orb.Geometry, byteOrder ...binary.ByteOrder) (string, error)
 func MustMarshal(geom orb.Geometry, byteOrder ...binary.ByteOrder) []byte
+func MustMarshalToHex(geom orb.Geometry, byteOrder ...binary.ByteOrder) string
 
 func NewEncoder(w io.Writer) *Encoder
 func (e *Encoder) SetByteOrder(bo binary.ByteOrder)

encoding/wkb/point_test.go

@@ -52,6 +52,34 @@ func TestPoint(t *testing.T) {
 	}
 }
 
+func TestPointToHex(t *testing.T) {
+	cases := []struct {
+		name     string
+		data     orb.Point
+		expected string
+	}{
+		{
+			name:     "point",
+			data:     orb.Point{1, 2},
+			expected: "0101000000000000000000f03f0000000000000040",
+		},
+		{
+			name:     "zero point",
+			data:     orb.Point{0, 0},
+			expected: "010100000000000000000000000000000000000000",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			s := MustMarshalToHex(tc.data)
+			if s != tc.expected {
+				t.Errorf("incorrect hex: %v", s)
+			}
+		})
+	}
+}
+
 var (
 	testMultiPoint     = orb.MultiPoint{{10, 40}, {40, 30}, {20, 20}, {30, 10}}
 	testMultiPointData = []byte{

encoding/wkb/wkb.go

@@ -5,6 +5,7 @@ package wkb
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
 	"errors"
 	"io"
 
@@ -88,6 +89,27 @@ func Marshal(geom orb.Geometry, byteOrder ...binary.ByteOrder) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
+// MarshalToHex will encode the geometry into a hex string representation of the binary wkb.
+func MarshalToHex(geom orb.Geometry, byteOrder ...binary.ByteOrder) (string, error) {
+	data, err := Marshal(geom, byteOrder...)
+	if err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(data), nil
+}
+
+// MustMarshalToHex will encode the geometry and panic on error.
+// Currently there is no reason to error during geometry marshalling.
+func MustMarshalToHex(geom orb.Geometry, byteOrder ...binary.ByteOrder) string {
+	d, err := MarshalToHex(geom, byteOrder...)
+	if err != nil {
+		panic(err)
+	}
+
+	return d
+}
+
 // NewEncoder creates a new Encoder for the given writer.
 func NewEncoder(w io.Writer) *Encoder {
 	e := wkbcommon.NewEncoder(w)