Use values for geometries

This reverts commit 9b6e0ec.

Signed-off-by: Sergio Garcez <[email protected]>

Author: sgarcez

feature.go

@@ -24,17 +24,17 @@ type Feature struct {
 // GeometryType is the type of the Feature's Geometry.
 func (f Feature) GeometryType() string {
 	switch f.geometry.(type) {
-	case *Point:
+	case Point:
 		return GeometryTypePoint
-	case *MultiPoint:
+	case MultiPoint:
 		return GeometryTypeMultiPoint
-	case *LineString:
+	case LineString:
 		return GeometryTypeLineString
-	case *MultiLineString:
+	case MultiLineString:
 		return GeometryTypeMultiLineString
-	case *Polygon:
+	case Polygon:
 		return GeometryTypePolygon
-	case *MultiPolygon:
+	case MultiPolygon:
 		return GeometryTypeMultiPolygon
 	case GeometryCollection:
 		return GeometryTypeGeometryCollection
@@ -44,74 +44,74 @@ func (f Feature) GeometryType() string {
 }
 
 // WithPoint sets the Feature's Geometry to the provided Point.
-func (f Feature) WithPoint(g *Point) Feature {
+func (f Feature) WithPoint(g Point) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsPoint casts the Feature's Geometry to a Point.
-func (f Feature) AsPoint() (*Point, bool) {
-	p, ok := f.geometry.(*Point)
+func (f Feature) AsPoint() (Point, bool) {
+	p, ok := f.geometry.(Point)
 	return p, ok
 }
 
 // WithMultiPoint sets the Feature's Geometry to the provided MultiPoint.
-func (f Feature) WithMultiPoint(g *MultiPoint) Feature {
+func (f Feature) WithMultiPoint(g MultiPoint) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsMultiPoint casts the Feature's Geometry to a MultiPoint.
-func (f Feature) AsMultiPoint() (*MultiPoint, bool) {
-	p, ok := f.geometry.(*MultiPoint)
+func (f Feature) AsMultiPoint() (MultiPoint, bool) {
+	p, ok := f.geometry.(MultiPoint)
 	return p, ok
 }
 
 // WithLineString sets the Feature's Geometry to the provided LineString.
-func (f Feature) WithLineString(g *LineString) Feature {
+func (f Feature) WithLineString(g LineString) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsLineString casts the Feature's Geometry to a LineString.
-func (f Feature) AsLineString() (*LineString, bool) {
-	p, ok := f.geometry.(*LineString)
+func (f Feature) AsLineString() (LineString, bool) {
+	p, ok := f.geometry.(LineString)
 	return p, ok
 }
 
 // WithMultiLineString sets the Feature's Geometry to the provided LineMultiString.
-func (f Feature) WithMultiLineString(g *MultiLineString) Feature {
+func (f Feature) WithMultiLineString(g MultiLineString) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsMultiLineString casts the Feature's Geometry to a MultiLineString.
-func (f Feature) AsMultiLineString() (*MultiLineString, bool) {
-	p, ok := f.geometry.(*MultiLineString)
+func (f Feature) AsMultiLineString() (MultiLineString, bool) {
+	p, ok := f.geometry.(MultiLineString)
 	return p, ok
 }
 
 // WithPolygon sets the Feature's Geometry to the provided Polygon.
-func (f Feature) WithPolygon(g *Polygon) Feature {
+func (f Feature) WithPolygon(g Polygon) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsPolygon casts the Feature's Geometry to a Polygon.
-func (f Feature) AsPolygon() (*Polygon, bool) {
-	p, ok := f.geometry.(*Polygon)
+func (f *Feature) AsPolygon() (Polygon, bool) {
+	p, ok := f.geometry.(Polygon)
 	return p, ok
 }
 
 // WithMultiPolygon sets the Feature's Geometry to the provided MultiPolygon.
-func (f Feature) WithMultiPolygon(g *MultiPolygon) Feature {
+func (f Feature) WithMultiPolygon(g MultiPolygon) Feature {
 	f.geometry = g
 	return f
 }
 
 // AsMultiPolygon casts the Feature's Geometry to a MultiPolygon.
-func (f *Feature) AsMultiPolygon() (*MultiPolygon, bool) {
-	p, ok := f.geometry.(*MultiPolygon)
+func (f *Feature) AsMultiPolygon() (MultiPolygon, bool) {
+	p, ok := f.geometry.(MultiPolygon)
 	return p, ok
 }
 
@@ -193,37 +193,37 @@ func unmarshalGeometry(bs []byte) (any, error) {
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypeMultiPoint:
 		var g MultiPoint
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypeLineString:
 		var g LineString
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypeMultiLineString:
 		var g MultiLineString
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypePolygon:
 		var g Polygon
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypeMultiPolygon:
 		var g MultiPolygon
 		if err := json.Unmarshal(bs, &g); err != nil {
 			return nil, err
 		}
-		return &g, nil
+		return g, nil
 	case GeometryTypeGeometryCollection:
 		var g GeometryCollection
 		if err := json.Unmarshal(bs, &g); err != nil {

feature_test.go

@@ -20,7 +20,7 @@ func TestFeature(t *testing.T) {
 			unmarshalErr: `unknown geometry type: ""`,
 		},
 		"Point": {
-			ft:   Feature{}.WithPoint(&Point{-170.0, 40.0}),
+			ft:   Feature{}.WithPoint(Point{-170.0, 40.0}),
 			json: `{"type":"Feature","geometry":{"coordinates":[-170,40],"type":"Point"}}`,
 			raw:  []float64{-170, 40},
 		},
@@ -30,28 +30,28 @@ func TestFeature(t *testing.T) {
 				Properties: map[string]any{
 					"foo": "bar",
 				},
-			}.WithPoint(&Point{-170.0, 40.0}),
+			}.WithPoint(Point{-170.0, 40.0}),
 			json: `{"id":"abc","type":"Feature","geometry":{"coordinates":[-170,40],"type":"Point"},"properties":{"foo":"bar"}}`,
 		},
 		"MultiPoint": {
 			ft: Feature{}.WithMultiPoint(
-				&MultiPoint{
+				MultiPoint{
 					{-170.0, 40.0},
 				}),
 			raw:  [][]float64{{-170, 40}},
 			json: `{"type":"Feature","geometry":{"coordinates":[[-170,40]],"type":"MultiPoint"}}`,
 		},
 		"LineString": {
 			ft: Feature{}.WithLineString(
-				&LineString{
+				LineString{
 					{-170.0, 40.0},
 				}),
 			raw:  [][]float64{{-170, 40}},
 			json: `{"type":"Feature","geometry":{"coordinates":[[-170,40]],"type":"LineString"}}`,
 		},
 		"MultiLineString": {
 			ft: Feature{}.WithMultiLineString(
-				&MultiLineString{
+				MultiLineString{
 					{
 						{-170.0, 40.0},
 					},
@@ -61,7 +61,7 @@ func TestFeature(t *testing.T) {
 		},
 		"Polygon": {
 			ft: Feature{}.WithPolygon(
-				&Polygon{
+				Polygon{
 					{
 						{-170.0, 40.0},
 					},
@@ -71,7 +71,7 @@ func TestFeature(t *testing.T) {
 		},
 		"MultiPolygon": {
 			ft: Feature{}.WithMultiPolygon(
-				&MultiPolygon{
+				MultiPolygon{
 					{
 						{
 							{-170.0, 40.0},
@@ -84,9 +84,9 @@ func TestFeature(t *testing.T) {
 		"GeometryCollection": {
 			ft: Feature{}.WithGeometryCollection(
 				GeometryCollection{}.AppendPoint(
-					&Point{-170.0, 40.0},
+					Point{-170.0, 40.0},
 				).AppendPolygon(
-					&Polygon{
+					Polygon{
 						{
 							{-170.0, 40.0},
 						},
@@ -119,42 +119,42 @@ func TestFeature(t *testing.T) {
 			case GeometryTypePoint:
 				got, ok := tt.ft.AsPoint()
 				assert.True(t, ok)
-				assert.IsType(t, &Point{}, got)
+				assert.IsType(t, Point{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
 			case GeometryTypeMultiPoint:
 				got, ok := tt.ft.AsMultiPoint()
 				assert.True(t, ok)
-				assert.IsType(t, &MultiPoint{}, got)
+				assert.IsType(t, MultiPoint{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
 			case GeometryTypeLineString:
 				got, ok := tt.ft.AsLineString()
 				assert.True(t, ok)
-				assert.IsType(t, &LineString{}, got)
+				assert.IsType(t, LineString{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
 			case GeometryTypeMultiLineString:
 				got, ok := tt.ft.AsMultiLineString()
 				assert.True(t, ok)
-				assert.IsType(t, &MultiLineString{}, got)
+				assert.IsType(t, MultiLineString{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
 			case GeometryTypePolygon:
 				got, ok := tt.ft.AsPolygon()
 				assert.True(t, ok)
-				assert.IsType(t, &Polygon{}, got)
+				assert.IsType(t, Polygon{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
 			case GeometryTypeMultiPolygon:
 				got, ok := tt.ft.AsMultiPolygon()
 				assert.True(t, ok)
-				assert.IsType(t, &MultiPolygon{}, got)
+				assert.IsType(t, MultiPolygon{}, got)
 				if tt.raw != nil {
 					assert.Equal(t, tt.raw, got.Raw())
 				}
@@ -176,59 +176,59 @@ func TestFeatureIDJSONMarshall(t *testing.T) {
 		err  string
 	}{
 		"string": {
-			ft:   Feature{ID: "1"}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: "1"}.WithPoint(Point{0, 0}),
 			json: `{"id":"1","type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"uint": {
-			ft:   Feature{ID: uint(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: uint(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"uint8": {
-			ft:   Feature{ID: uint8(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: uint8(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"uint16": {
-			ft:   Feature{ID: uint16(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: uint16(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"uint32": {
-			ft:   Feature{ID: uint32(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: uint32(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"uint64": {
-			ft:   Feature{ID: uint64(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: uint64(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"int": {
-			ft:   Feature{ID: int(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: int(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"int8": {
-			ft:   Feature{ID: int8(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: int8(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"int16": {
-			ft:   Feature{ID: int16(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: int16(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"int32": {
-			ft:   Feature{ID: int32(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: int32(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"int64": {
-			ft:   Feature{ID: int64(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: int64(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"float32": {
-			ft:   Feature{ID: float32(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: float32(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"float64": {
-			ft:   Feature{ID: float64(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: float64(1)}.WithPoint(Point{0, 0}),
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
 		},
 		"other type than int or string": {
-			ft:  Feature{ID: true}.WithPoint(&Point{0, 0}),
+			ft:  Feature{ID: true}.WithPoint(Point{0, 0}),
 			err: `json: error calling MarshalJSON for type joejson.Feature: invalid type "bool" for id, expected string or numeric`,
 		},
 	}
@@ -258,15 +258,15 @@ func TestFeatureIDJSONUnmarshall(t *testing.T) {
 	}{
 		"string": {
 			json: `{"id":"1","type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
-			ft:   Feature{ID: "1"}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: "1"}.WithPoint(Point{0, 0}),
 		},
 		"integer": {
 			json: `{"id":1,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
-			ft:   Feature{ID: float64(1)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: float64(1)}.WithPoint(Point{0, 0}),
 		},
 		"decimal": {
 			json: `{"id":1.5,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,
-			ft:   Feature{ID: float64(1.5)}.WithPoint(&Point{0, 0}),
+			ft:   Feature{ID: float64(1.5)}.WithPoint(Point{0, 0}),
 		},
 		"other type than numeric or string": {
 			json: `{"id":true,"type":"Feature","geometry":{"coordinates":[0,0],"type":"Point"}}`,