Added generic type parameter for Tree to represent node data. Tests not passing for deserialize

Author: kingledion

tree/index.go

@@ -2,9 +2,9 @@ package tree
 
 import "log"
 
-type index map[uint]Node
+type index[T any] map[uint]Node[T]
 
-func (idx *index) find(id uint) Node {
+func (idx *index[T]) find(id uint) Node[T] {
 	if idx == nil { // do we need an error check here?
 		log.Println("Attempting to find in an undefined index")
 		return nil
@@ -17,7 +17,7 @@ func (idx *index) find(id uint) Node {
 	return val
 }
 
-func (idx *index) insert(id uint, node Node) bool {
+func (idx *index[T]) insert(id uint, node Node[T]) bool {
 	if idx == nil { // do we need an error check here?
 		log.Println("Attempting to insert in an undefined index")
 		return false

tree/index_test.go

@@ -8,29 +8,29 @@ import (
 
 func TestIndexFind(t *testing.T) {
 
-	node1 := &node{Primary: 1}
-	node2 := &node{Primary: 2}
+	node1 := &node[int]{primary: 1}
+	node2 := &node[int]{primary: 2}
 
 	tests := map[string]struct {
-		index   index
+		index   index[int]
 		argID   uint
-		expNode Node
+		expNode Node[int]
 	}{
 		"nil index": {
 			index:   nil,
 			argID:   1,
 			expNode: nil,
 		},
 		"not in index": {
-			index: index{
+			index: index[int]{
 				1: node1,
 				2: node2,
 			},
 			argID:   3,
 			expNode: nil,
 		},
 		"success": {
-			index: index{
+			index: index[int]{
 				1: node1,
 				2: node2,
 			},

tree/node.go

@@ -31,93 +31,93 @@ import (
 // When this node is serialized, only the id and parent id, along with
 // associated data are serialized. The internal pointers to parent and children
 // are recreated with the nodes are deserialized.
-type Node interface {
+type Node[T any] interface {
 	// GetID returns the primary key of this node.
 	GetID() uint
 	// GetParentID returns the primary key of this node's parent.
 	GetParentID() uint
 
 	// GetChildren returns an array of pointers to all children of this node.
-	GetChildren() []Node
+	GetChildren() []Node[T]
 	// GetParent returns a pointer to the parent node of this node.
-	GetParent() Node
+	GetParent() Node[T]
 
 	// AddChildren adds a list of Nodes as children of this node.
-	AddChildren(...Node)
+	AddChildren(...Node[T])
 	// ReplaceChildren replaces the current list of children with a new list of
 	// Nodes.
-	ReplaceChildren(...Node)
+	ReplaceChildren(...Node[T])
 
-	setParent(n Node)
+	setParent(n Node[T])
 
 	// GetData retruns this node's internal data.
-	GetData() any
+	GetData() T
 	// SetData replaces this nodes data with the argument. The argument may be any
 	// type, but must be serializable via json.
 	//
 	// This function does not attempt to test json encoding when the data is set;
 	// any error with encoding will only occur when the data is serialized
 	// to a repository.
-	SetData(any)
+	SetData(T)
 }
 
-type node struct {
-	Primary  uint
-	ParentID uint
-	parent   Node
-	Data     any
-	children []Node
+type node[T any] struct {
+	primary  uint
+	parentID uint
+	parent   Node[T]
+	data     T
+	children []Node[T]
 }
 
-func (n *node) GetID() uint {
-	return n.Primary
+func (n *node[T]) GetID() uint {
+	return n.primary
 }
 
-func (n *node) GetParentID() uint {
-	return n.ParentID
+func (n *node[T]) GetParentID() uint {
+	return n.parentID
 }
 
-func (n *node) GetChildren() []Node {
+func (n *node[T]) GetChildren() []Node[T] {
 	return n.children
 }
 
-func (n *node) GetParent() Node {
+func (n *node[T]) GetParent() Node[T] {
 	return n.parent
 }
 
-func (n *node) AddChildren(children ...Node) {
+func (n *node[T]) AddChildren(children ...Node[T]) {
 	if n.children == nil {
-		n.children = []Node{}
+		n.children = []Node[T]{}
 	}
 	n.children = append(n.children, children[:]...)
 }
 
-func (n *node) ReplaceChildren(children ...Node) {
-	n.children = []Node{}
+func (n *node[T]) ReplaceChildren(children ...Node[T]) {
+	n.children = []Node[T]{}
 	n.AddChildren(children...)
 }
 
-func (n *node) setParent(parent Node) {
+func (n *node[T]) setParent(parent Node[T]) {
 	if parent == nil || parent.GetID() == n.GetID() {
 		return
 	}
 	n.parent = parent
-	n.ParentID = parent.GetID()
+	n.parentID = parent.GetID()
 
 }
 
-func (n *node) GetData() any {
-	return n.Data
+func (n *node[T]) GetData() T {
+	return n.data
 }
 
-func (n *node) SetData(newdata any) {
-	n.Data = newdata
+func (n *node[T]) SetData(newdata T) {
+	n.data = newdata
 }
 
-func (n *node) Format(f fmt.State, verb rune) {
+func (n *node[T]) Format(f fmt.State, verb rune) {
 	switch verb {
 	case 'v':
-		fmt.Fprintf(f, "{primary: %d parentID: %d data:%+v children:[", n.Primary, n.ParentID, n.Data)
+		fmt.Fprintf(f, "{primary: %d parentID: %d data:%+v children:[", n.primary, n.parentID, n.data)
 		for i, n := range n.children {
 			if i != 0 {
 				fmt.Fprint(f, " ")