AssociativeListCandidateFieldNames lists the field names which are considered keys if found in a list element.
var AssociativeListCandidateFieldNames = []string{ "key", "id", "name", }
var ErrUnknownPathElementType = errors.New("unknown path element type")
func KeyByFields(nameValues ...interface{}) *value.FieldList
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 SerializePathElement(pe PathElement) (string, error)
SerializePathElement serializes a path element
APIVersion describes the version of an object or of a fieldset.
type APIVersion string
ManagedFields is a map from manager to VersionedSet (what they own in what version).
type ManagedFields map[string]VersionedSet
func (lhs ManagedFields) Copy() ManagedFields
Copy the list, this is mostly a shallow copy.
func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields
Difference returns a symmetric difference between two Managers. If a given user's entry has version X in lhs and version Y in rhs, then the return value for that user will be from rhs. If the difference for a user is an empty set, that user will not be inserted in the map.
func (lhs ManagedFields) Equals(rhs ManagedFields) bool
Equals returns true if the two managedfields are the same, false otherwise.
func (lhs ManagedFields) String() string
Path describes how to select a potentially deeply-nested child field given a containing object.
type Path []PathElement
func MakePath(parts ...interface{}) (Path, error)
MakePath constructs a Path. The parts may be PathElements, ints, strings.
func MakePathOrDie(parts ...interface{}) Path
MakePathOrDie panics if parts can't be turned into a path. Good for things that are known at complie time.
func (fp Path) Compare(rhs Path) int
Less provides a lexical order for Paths.
func (fp Path) Copy() Path
func (fp Path) Equals(fp2 Path) bool
Equals returns true if the two paths are equivalent.
func (fp Path) String() string
PathElement describes how to select a child field given a containing object.
type PathElement struct {
// FieldName selects a single field from a map (reminder: this is also
// how structs are represented). The containing object must be a map.
FieldName *string
// Key selects the list element which has fields matching those given.
// The containing object must be an associative list with map typed
// elements. They are sorted alphabetically.
Key *value.FieldList
// Value selects the list element with the given value. The containing
// object must be an associative list with a primitive typed element
// (i.e., a set).
Value *value.Value
// Index selects a list element by its index number. The containing
// object must be an atomic list.
Index *int
}
func DeserializePathElement(s string) (PathElement, error)
DeserializePathElement parses a serialized path element
func (e PathElement) Compare(rhs PathElement) int
Compare provides an order for path elements.
func (e PathElement) Equals(rhs PathElement) bool
Equals returns true if both path elements are equal.
func (e PathElement) Less(rhs PathElement) bool
Less provides an order for path elements.
func (e PathElement) String() string
String presents the path element as a human-readable string.
PathElementValueMap is a map from PathElement to interface{}.
type PathElementMap struct {
// contains filtered or unexported fields
}
func MakePathElementMap(size int) PathElementMap
func (s *PathElementMap) Get(pe PathElement) (interface{}, bool)
Get retrieves the value associated with the given PathElement from the map. (nil, false) is returned if there is no such PathElement.
func (s *PathElementMap) Insert(pe PathElement, v interface{})
Insert adds the pathelement and associated value in the map. If insert is called twice with the same PathElement, the value is replaced.
PathElementSet is a set of path elements. TODO: serialize as a list.
type PathElementSet struct {
// contains filtered or unexported fields
}
func MakePathElementSet(size int) PathElementSet
func (s *PathElementSet) Difference(s2 *PathElementSet) *PathElementSet
Difference returns a set containing elements which appear in s but not in s2.
func (s *PathElementSet) Equals(s2 *PathElementSet) bool
Equals returns true if s and s2 have exactly the same members.
func (s *PathElementSet) Has(pe PathElement) bool
Has returns true if pe is a member of the set.
func (s *PathElementSet) Insert(pe PathElement)
Insert adds pe to the set.
func (s *PathElementSet) Intersection(s2 *PathElementSet) *PathElementSet
Intersection returns a set containing elements which appear in both s and s2.
func (s *PathElementSet) Iterate(f func(PathElement))
Iterate calls f for each PathElement in the set. The order is deterministic.
func (s *PathElementSet) Size() int
Size retuns the number of elements in the set.
func (s *PathElementSet) Union(s2 *PathElementSet) *PathElementSet
Union returns a set containing elements that appear in either s or s2.
PathElementValueMap is a map from PathElement to value.Value.
TODO(apelisse): We have multiple very similar implementation of this for PathElementSet and SetNodeMap, so we could probably share the code.
type PathElementValueMap struct {
// contains filtered or unexported fields
}
func MakePathElementValueMap(size int) PathElementValueMap
func (s *PathElementValueMap) Get(pe PathElement) (value.Value, bool)
Get retrieves the value associated with the given PathElement from the map. (nil, false) is returned if there is no such PathElement.
func (s *PathElementValueMap) Insert(pe PathElement, v value.Value)
Insert adds the pathelement and associated value in the map. If insert is called twice with the same PathElement, the value is replaced.
Set identifies a set of fields.
type Set struct {
// Members lists fields that are part of the set.
// TODO: will be serialized as a list of path elements.
Members PathElementSet
// Children lists child fields which themselves have children that are
// members of the set. Appearance in this list does not imply membership.
// Note: this is a tree, not an arbitrary graph.
Children SetNodeMap
}
func NewSet(paths ...Path) *Set
NewSet makes a set from a list of paths.
func SetFromValue(v value.Value) *Set
SetFromValue creates a set containing every leaf field mentioned in v.
func (s *Set) Difference(s2 *Set) *Set
Difference returns a Set containing elements which: * appear in s * do not appear in s2
In other words, for leaf fields, this acts like a regular set difference operation. When non leaf fields are compared with leaf fields ("parents" which contain "children"), the effect is: * parent - child = parent * child - parent = {empty set}
func (s *Set) Empty() bool
Empty returns true if there are no members of the set. It is a separate function from Size since it's common to check whether size > 0, and potentially much faster to return as soon as a single element is found.
func (s *Set) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.TypeRef) *Set
EnsureNamedFieldsAreMembers returns a Set that contains all the fields in s, as well as all the named fields that are typically not included. For example, a set made of "a.b.c" will end-up also owning "a" if it's a named fields but not "a.b" if it's a map.
func (s *Set) Equals(s2 *Set) bool
Equals returns true if s and s2 have exactly the same members.
func (s *Set) FromJSON(r io.Reader) error
FromJSON clears s and reads a JSON formatted set structure.
func (s *Set) Has(p Path) bool
Has returns true if the field referenced by `p` is a member of the set.
func (s *Set) Insert(p Path)
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) Intersection(s2 *Set) *Set
Intersection returns a Set containing leaf elements which appear in both s and s2. Intersection can be constructed from Union and Difference operations (example in the tests) but it's much faster to do it in one pass.
func (s *Set) Iterate(f func(Path))
Iterate calls f once for each field that is a member of the set (preorder DFS). The path passed to f will be reused so make a copy if you wish to keep it.
func (s *Set) Leaves() *Set
Leaves returns a set containing only the leaf paths of a set.
func (s *Set) RecursiveDifference(s2 *Set) *Set
RecursiveDifference returns a Set containing elements which: * appear in s * do not appear in s2
Compared to a regular difference, this removes every field **and its children** from s that is contained in s2.
For example, with s containing `a.b.c` and s2 containing `a.b`, a RecursiveDifference will result in `a`, as the entire node `a.b` gets removed.
func (s *Set) Size() int
Size returns the number of members of the set.
func (s *Set) String() string
String returns the set one element per line.
func (s *Set) ToJSON() ([]byte, error)
func (s *Set) ToJSONStream(w io.Writer) error
func (s *Set) Union(s2 *Set) *Set
Union returns a Set containing elements which appear in either s or s2.
func (s *Set) WithPrefix(pe PathElement) *Set
WithPrefix returns the subset of paths which begin with the given prefix, with the prefix not included.
SetNodeMap is a map of PathElement to subset.
type SetNodeMap struct {
// contains filtered or unexported fields
}
func (s *SetNodeMap) Descend(pe PathElement) *Set
Descend adds pe to the set if necessary, returning the associated subset.
func (s *SetNodeMap) Difference(s2 *Set) *SetNodeMap
Difference returns a SetNodeMap with members that appear in s but not in s2.
func (s *SetNodeMap) Empty() bool
Empty returns false if there's at least one member in some child set.
func (s *SetNodeMap) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.TypeRef) *SetNodeMap
EnsureNamedFieldsAreMembers returns a set that contains all the named fields along with the leaves.
func (s *SetNodeMap) Equals(s2 *SetNodeMap) bool
Equals returns true if s and s2 have the same structure (same nested child sets).
func (s *SetNodeMap) Get(pe PathElement) (*Set, bool)
Get returns (the associated set, true) or (nil, false) if there is none.
func (s *SetNodeMap) Intersection(s2 *SetNodeMap) *SetNodeMap
Intersection returns a SetNodeMap with members that appear in both s and s2.
func (s *SetNodeMap) Iterate(f func(PathElement))
Iterate calls f for each PathElement in the set.
func (s *SetNodeMap) Leaves() *SetNodeMap
Leaves returns a SetNodeMap containing only setNodes with leaf PathElements.
func (s *SetNodeMap) RecursiveDifference(s2 *Set) *SetNodeMap
RecursiveDifference returns a SetNodeMap with members that appear in s but not in s2.
Compared to a regular difference, this removes every field **and its children** from s that is contained in s2.
For example, with s containing `a.b.c` and s2 containing `a.b`, a RecursiveDifference will result in `a`, as the entire node `a.b` gets removed.
func (s *SetNodeMap) Size() int
Size returns the sum of the number of members of all subsets.
func (s *SetNodeMap) Union(s2 *SetNodeMap) *SetNodeMap
Union returns a SetNodeMap with members that appear in either s or s2.
type VersionedSet interface {
Set() *Set
APIVersion() APIVersion
Applied() bool
}
func NewVersionedSet(set *Set, apiVersion APIVersion, applied bool) VersionedSet