More point quality of life improvements. (#201)

* More point quality of life improvements.

1. Add a point key that can be used in Maps. Add a test.
2. Move SGF logic to a separate file
3. Add an equals method for points.

Fixes: #196

Author: artasparks

core/point/point.go

@@ -12,29 +12,6 @@ type Point struct {
 	y int64
 }
 
-// pointToSgfMap is a translation reference between int64 Point
-// and string SGF-Point (rune) values
-var pointToSgfMap = map[int64]rune{
-	0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g',
-	7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n',
-	14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u',
-	21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B',
-	28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I',
-	35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P',
-	42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W',
-	49: 'X', 50: 'Y', 51: 'Z',
-}
-
-// sgfToPointMap is a translation reference between string SGF-Point
-// (rune) values and int64 Point values
-var sgfToPointMap = func(m map[int64]rune) map[rune]int64 {
-	out := make(map[rune]int64)
-	for key, val := range m {
-		out[val] = key
-	}
-	return out
-}(pointToSgfMap)
-
 // New creates a new immutable Point.
 func New(x, y int64) *Point {
 	return &Point{
@@ -52,29 +29,34 @@ func (pt *Point) Y() int64 { return pt.y }
 // ToSGF converts a pointer-type (immutable) *Point
 // to an SGF Point (two letter string).
 func (pt *Point) ToSGF() (string, error) {
-	if pt.X() < 0 || pt.X() > 51 || pt.Y() < 0 || pt.Y() > 51 {
-		return "", fmt.Errorf("error converting point to SGF-point; points must be between 0 and 51 inclusive. found %v", pt.String())
-	}
-	return string(pointToSgfMap[pt.X()]) + string(pointToSgfMap[pt.Y()]), nil
+	return toSGF(pt)
+}
+
+// Equals returns whether this point is equal to another point.
+func (pt *Point) Equals(other *Point) bool {
+	return pt.X() == other.X() && pt.Y() == other.Y()
 }
 
 // String converts to string representation of a Point.
-func (pt Point) String() string {
+func (pt *Point) String() string {
 	return fmt.Sprintf("{%d,%d}", pt.x, pt.y)
 }
 
-// NewFromSGF converts an SGF point (two letter string) to a Point.
-func NewFromSGF(sgfPt string) (*Point, error) {
-	if sgfPt == "" || len(sgfPt) != 2 {
-		return nil, fmt.Errorf("sgf point must be non-empty and two letter char, but was %s", sgfPt)
-	}
-	intX, ok := sgfToPointMap[rune(sgfPt[0])]
-	if !ok {
-		return nil, fmt.Errorf("could not convert coordinate for x-value of sgf point %s; only a-zA-Z (minus i/I) are allowed", sgfPt)
-	}
-	intY, ok := sgfToPointMap[rune(sgfPt[1])]
-	if !ok {
-		return nil, fmt.Errorf("could not convert coordinate for y-value of sgf point %s; only a-zA-Z (minus i/I) are allowed", sgfPt)
-	}
-	return New(intX, intY), nil
+// Key is a convenience helper to convert this point to a key-struct.
+func (pt *Point) Key() Key {
+	return Key{X: pt.X(), Y: pt.Y()}
+}
+
+// Key is a point-struct that is used for keys in maps. As such, it's intended
+// to be used like the following:
+//
+//     Key{X:12, Y:15}
+type Key struct {
+	X int64
+	Y int64
+}
+
+// Point converts a point-Key back to a point.
+func (k Key) Point() *Point {
+	return New(k.X, k.Y)
 }

core/point/point_test.go

@@ -140,5 +140,20 @@ func TestSGFToPointTranslate(t *testing.T) {
 			}
 		})
 	}
+}
+
+func TestKey(t *testing.T) {
+	pt := New(12, 15)
+
+	key := pt.Key()
+	exp := Key{X: 12, Y: 15}
 
+	if key != exp {
+		t.Errorf("error converting point to key: got %v, but expected %v", key, exp)
+	}
+
+	back := exp.Point()
+	if !pt.Equals(back) {
+		t.Errorf("error converting key to point: got %v, but expected %v", back, pt)
+	}
 }

core/point/sgf.go

@@ -0,0 +1,52 @@
+package point
+
+import "fmt"
+
+// TODO(kashomon): This whole file needs to be moved to core/sgf
+
+// pointToSgfMap is a translation reference between int64 Point
+// and string SGF-Point (rune) values
+var pointToSgfMap = map[int64]rune{
+	0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g',
+	7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n',
+	14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u',
+	21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B',
+	28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I',
+	35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P',
+	42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W',
+	49: 'X', 50: 'Y', 51: 'Z',
+}
+
+// sgfToPointMap is a translation reference between string SGF-Point
+// (rune) values and int64 Point values
+var sgfToPointMap = func(m map[int64]rune) map[rune]int64 {
+	out := make(map[rune]int64)
+	for key, val := range m {
+		out[val] = key
+	}
+	return out
+}(pointToSgfMap)
+
+// NewFromSGF converts an SGF point (two letter string) to a Point.
+func NewFromSGF(sgfPt string) (*Point, error) {
+	if sgfPt == "" || len(sgfPt) != 2 {
+		return nil, fmt.Errorf("sgf point must be non-empty and two letter char, but was %s", sgfPt)
+	}
+	intX, ok := sgfToPointMap[rune(sgfPt[0])]
+	if !ok {
+		return nil, fmt.Errorf("could not convert coordinate for x-value of sgf point %s; only a-zA-Z (minus i/I) are allowed", sgfPt)
+	}
+	intY, ok := sgfToPointMap[rune(sgfPt[1])]
+	if !ok {
+		return nil, fmt.Errorf("could not convert coordinate for y-value of sgf point %s; only a-zA-Z (minus i/I) are allowed", sgfPt)
+	}
+	return New(intX, intY), nil
+}
+
+// toSGF converts a point to an SGF coordinate.
+func toSGF(pt *Point) (string, error) {
+	if pt.X() < 0 || pt.X() > 51 || pt.Y() < 0 || pt.Y() > 51 {
+		return "", fmt.Errorf("error converting point to SGF-point; points must be between 0 and 51 inclusive. found %v", pt.String())
+	}
+	return string(pointToSgfMap[pt.X()]) + string(pointToSgfMap[pt.Y()]), nil
+}