kubernetes/vendor/sigs.k8s.io/structured-merge-diff/v4/fieldpath/element.go

type PathElement …

// Less provides an order for path elements.
func (e PathElement) Less(rhs PathElement) bool { … }

// Compare provides an order for path elements.
func (e PathElement) Compare(rhs PathElement) int { … }

// Equals returns true if both path elements are equal.
func (e PathElement) Equals(rhs PathElement) bool { … }

// String presents the path element as a human-readable string.
func (e PathElement) String() string { … }

// 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
// conditions are not met, KeyByFields will panic--it's intended for static
// construction and shouldn't have user-produced values passed to it.
func KeyByFields(nameValues ...interface{ … }

type PathElementSet …

func MakePathElementSet(size int) PathElementSet { … }

type sortedPathElements …

// Implement the sort interface; this would permit bulk creation, which would
// be faster than doing it one at a time via Insert.
func (spe sortedPathElements) Len() int           { … }

func (spe sortedPathElements) Less(i, j int) bool { … }

func (spe sortedPathElements) Swap(i, j int)      { … }

// Insert adds pe to the set.
func (s *PathElementSet) Insert(pe PathElement) { … }

// Union returns a set containing elements that appear in either s or s2.
func (s *PathElementSet) Union(s2 *PathElementSet) *PathElementSet { … }

// Intersection returns a set containing elements which appear in both s and s2.
func (s *PathElementSet) Intersection(s2 *PathElementSet) *PathElementSet { … }

// Difference returns a set containing elements which appear in s but not in s2.
func (s *PathElementSet) Difference(s2 *PathElementSet) *PathElementSet { … }

// Size retuns the number of elements in the set.
func (s *PathElementSet) Size() int { … }

// Has returns true if pe is a member of the set.
func (s *PathElementSet) Has(pe PathElement) bool { … }

// Equals returns true if s and s2 have exactly the same members.
func (s *PathElementSet) Equals(s2 *PathElementSet) bool { … }

// Iterate calls f for each PathElement in the set. The order is deterministic.
func (s *PathElementSet) Iterate(f func(PathElement)) { … }