Add copy and iterator utils

Author: jpbetz

fieldpath/element.go

@@ -18,6 +18,7 @@ package fieldpath
 
 import (
 	"fmt"
+	"iter"
 	"sort"
 	"strings"
 
@@ -156,6 +157,25 @@ func (e PathElement) String() string {
 	}
 }
 
+// Copy returns a copy of the PathElement.
+// This is not a full deep copy as any contained value.Value is not copied.
+func (e PathElement) Copy() PathElement {
+	if e.FieldName != nil {
+		return PathElement{FieldName: e.FieldName}
+	}
+	if e.Key != nil {
+		c := e.Key.Copy()
+		return PathElement{Key: &c}
+	}
+	if e.Value != nil {
+		return PathElement{Value: e.Value}
+	}
+	if e.Index != nil {
+		return PathElement{Index: e.Index}
+	}
+	return e // zero value
+}
+
 // KeyByFields is a helper function which constructs a key for an associative
 // list type. `nameValues` must have an even number of entries, alternating
 // names (type must be string) with values (type must be value.Value). If these
@@ -193,6 +213,16 @@ func (spe sortedPathElements) Len() int           { return len(spe) }
 func (spe sortedPathElements) Less(i, j int) bool { return spe[i].Less(spe[j]) }
 func (spe sortedPathElements) Swap(i, j int)      { spe[i], spe[j] = spe[j], spe[i] }
 
+// Copy returns a copy of the PathElementSet.
+// This is not a full deep copy as any contained value.Value is not copied.
+func (s PathElementSet) Copy() PathElementSet {
+	out := make(sortedPathElements, len(s.members))
+	for i := range s.members {
+		out[i] = s.members[i].Copy()
+	}
+	return PathElementSet{members: out}
+}
+
 // Insert adds pe to the set.
 func (s *PathElementSet) Insert(pe PathElement) {
 	loc := sort.Search(len(s.members), func(i int) bool {
@@ -315,3 +345,14 @@ func (s *PathElementSet) Iterate(f func(PathElement)) {
 		f(pe)
 	}
 }
+
+// All iterates over each PathElement in the set. The order is deterministic.
+func (s *PathElementSet) All() iter.Seq[PathElement] {
+	return func(yield func(element PathElement) bool) {
+		for _, pe := range s.members {
+			if !yield(pe) {
+				return
+			}
+		}
+	}
+}

fieldpath/element_test.go

@@ -33,6 +33,10 @@ func TestPathElementSet(t *testing.T) {
 	if !s2.Has(PathElement{}) {
 		t.Errorf("expected to have something: %#v", s2)
 	}
+	c2 := s2.Copy()
+	if !c2.Equals(s2) {
+		t.Errorf("expected copy to equal original: %#v, %#v", s2, c2)
+	}
 
 	n1 := "aoeu"
 	n2 := "asdf"
@@ -60,6 +64,20 @@ func TestPathElementSet(t *testing.T) {
 		}
 		i++
 	})
+	i = 0
+	for pe := range s2.All() {
+		e, a := expected[i], pe.FieldName
+		if e == nil || a == nil {
+			if e != a {
+				t.Errorf("index %v wanted %#v, got %#v", i, e, a)
+			}
+		} else {
+			if *e != *a {
+				t.Errorf("index %v wanted %#v, got %#v", i, *e, *a)
+			}
+		}
+		i++
+	}
 }
 
 func strptr(s string) *string { return &s }

fieldpath/set.go

@@ -18,6 +18,7 @@ package fieldpath
 
 import (
 	"fmt"
+	"iter"
 	"sort"
 	"strings"
 
@@ -47,6 +48,15 @@ func NewSet(paths ...Path) *Set {
 	return s
 }
 
+// Copy returns a copy of the Set.
+// This is not a full deep copy as any contained value.Value is not copied.
+func (s *Set) Copy() *Set {
+	return &Set{
+		Members:  s.Members.Copy(),
+		Children: s.Children.Copy(),
+	}
+}
+
 // Insert adds the field identified by `p` to the set. Important: parent fields
 // are NOT added to the set; if that is desired, they must be added separately.
 func (s *Set) Insert(p Path) {
@@ -386,6 +396,15 @@ func (s *Set) Iterate(f func(Path)) {
 	s.iteratePrefix(Path{}, f)
 }
 
+// All iterates over each Path in the set (preorder DFS).
+func (s *Set) All() iter.Seq[Path] {
+	return func(yield func(Path) bool) {
+		s.Iterate(func(p Path) {
+			yield(p)
+		})
+	}
+}
+
 func (s *Set) iteratePrefix(prefix Path, f func(Path)) {
 	s.Members.Iterate(func(pe PathElement) { f(append(prefix, pe)) })
 	s.Children.iteratePrefix(prefix, f)
@@ -455,6 +474,16 @@ func (s sortedSetNode) Len() int           { return len(s) }
 func (s sortedSetNode) Less(i, j int) bool { return s[i].pathElement.Less(s[j].pathElement) }
 func (s sortedSetNode) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
+// Copy returns a copy of the SetNodeMap.
+// This is not a full deep copy as any contained value.Value is not copied.
+func (s *SetNodeMap) Copy() SetNodeMap {
+	out := make(sortedSetNode, len(s.members))
+	for i, v := range s.members {
+		out[i] = setNode{pathElement: v.pathElement.Copy(), set: v.set.Copy()}
+	}
+	return SetNodeMap{members: out}
+}
+
 // Descend adds pe to the set if necessary, returning the associated subset.
 func (s *SetNodeMap) Descend(pe PathElement) *Set {
 	loc := sort.Search(len(s.members), func(i int) bool {
@@ -705,6 +734,15 @@ func (s *SetNodeMap) Iterate(f func(PathElement)) {
 	}
 }
 
+// All iterates over each PathElement in the set.
+func (s *SetNodeMap) All() iter.Seq[PathElement] {
+	return func(yield func(PathElement) bool) {
+		s.Iterate(func(pe PathElement) {
+			yield(pe)
+		})
+	}
+}
+
 func (s *SetNodeMap) iteratePrefix(prefix Path, f func(Path)) {
 	for _, n := range s.members {
 		pe := n.pathElement

fieldpath/set_test.go

@@ -233,7 +233,6 @@ func TestSetIterSize(t *testing.T) {
 	)
 
 	s2 := NewSet()
-
 	addedCount := 0
 	s1.Iterate(func(p Path) {
 		if s2.Size() != addedCount {
@@ -246,6 +245,19 @@ func TestSetIterSize(t *testing.T) {
 		addedCount++
 	})
 
+	s2 = NewSet()
+	addedCount = 0
+	for p := range s1.All() {
+		if s2.Size() != addedCount {
+			t.Errorf("added %v items to set, but size is %v", addedCount, s2.Size())
+		}
+		if addedCount > 0 == s2.Empty() {
+			t.Errorf("added %v items to set, but s2.Empty() is %v", addedCount, s2.Empty())
+		}
+		s2.Insert(p)
+		addedCount++
+	}
+
 	if !s1.Equals(s2) {
 		// No point in using String() if iterate is broken...
 		t.Errorf("Iterate missed something?\n%#v\n%#v", s1, s2)
@@ -756,6 +768,19 @@ func TestSetNodeMapIterate(t *testing.T) {
 			t.Errorf("expected to have iterated over %v, but never did", pe)
 		}
 	}
+
+	iteratedElements = make(map[string]bool, toAdd)
+	for pe := range set.All() {
+		iteratedElements[pe.String()] = true
+	}
+	if len(iteratedElements) != toAdd {
+		t.Errorf("expected %v elements to be iterated over, got %v", toAdd, len(iteratedElements))
+	}
+	for _, pe := range addedElements {
+		if _, ok := iteratedElements[pe]; !ok {
+			t.Errorf("expected to have iterated over %v, but never did", pe)
+		}
+	}
 }
 
 func TestFilterByPattern(t *testing.T) {

go.mod

@@ -12,4 +12,4 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 )
 
-go 1.19
+go 1.23

value/fields.go

@@ -31,6 +31,14 @@ type Field struct {
 // have a different name.
 type FieldList []Field
 
+// Copy returns a copy of the FieldList.
+// Values are not copied.
+func (f FieldList) Copy() FieldList {
+	c := make(FieldList, len(f))
+	copy(c, f)
+	return c
+}
+
 // Sort sorts the field list by Name.
 func (f FieldList) Sort() {
 	if len(f) < 2 {