type Set … // NewSet makes a set from a list of paths. func NewSet(paths ...Path) *Set { … } // 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) { … } // Union returns a Set containing elements which appear in either s or s2. func (s *Set) Union(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) Intersection(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) Difference(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) RecursiveDifference(s2 *Set) *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) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.TypeRef) *Set { … } // MakePrefixMatcherOrDie is the same as PrefixMatcher except it panics if parts can't be // turned into a SetMatcher. func MakePrefixMatcherOrDie(parts ...interface{ … } // PrefixMatcher creates a SetMatcher that matches all field paths prefixed by the given list of matcher path parts. // The matcher parts may any of: // // - PathElementMatcher - for wildcards, `MatchAnyPathElement()` can be used as well. // - PathElement - for any path element // - value.FieldList - for listMap keys // - value.Value - for scalar list elements // - string - For field names // - int - for array indices func PrefixMatcher(parts ...interface{ … } // MatchAnyPathElement returns a PathElementMatcher that matches any path element. func MatchAnyPathElement() PathElementMatcher { … } // MatchAnySet returns a SetMatcher that matches any set. func MatchAnySet() *SetMatcher { … } // NewSetMatcher returns a new SetMatcher. // Wildcard members take precedent over non-wildcard members; // all non-wildcard members are ignored if there is a wildcard members. func NewSetMatcher(wildcard bool, members ...*SetMemberMatcher) *SetMatcher { … } type SetMatcher … type sortedMemberMatcher … func (s sortedMemberMatcher) Len() int { … } func (s sortedMemberMatcher) Less(i, j int) bool { … } func (s sortedMemberMatcher) Swap(i, j int) { … } func (s sortedMemberMatcher) Find(p PathElementMatcher) (location int, ok bool) { … } // Merge merges s and s2 and returns a SetMatcher that matches all field paths matched by either s or s2. // During the merge, members of s and s2 with the same PathElementMatcher merged into a single member // with the children of each merged by calling this function recursively. func (s *SetMatcher) Merge(s2 *SetMatcher) *SetMatcher { … } type SetMemberMatcher … type PathElementMatcher … func (p PathElementMatcher) Equals(p2 PathElementMatcher) bool { … } func (p PathElementMatcher) Less(p2 PathElementMatcher) bool { … } func (p PathElementMatcher) Compare(p2 PathElementMatcher) int { … } // FilterIncludeMatches returns a Set with only the field paths that match. func (s *Set) FilterIncludeMatches(pattern *SetMatcher) *Set { … } // Size returns the number of members of the set. func (s *Set) Size() int { … } // 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) Empty() bool { … } // Has returns true if the field referenced by `p` is a member of the set. func (s *Set) Has(p Path) bool { … } // Equals returns true if s and s2 have exactly the same members. func (s *Set) Equals(s2 *Set) bool { … } // String returns the set one element per line. func (s *Set) String() string { … } // 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) Iterate(f func(Path)) { … } func (s *Set) iteratePrefix(prefix Path, f func(Path)) { … } // WithPrefix returns the subset of paths which begin with the given prefix, // with the prefix not included. func (s *Set) WithPrefix(pe PathElement) *Set { … } // Leaves returns a set containing only the leaf paths // of a set. func (s *Set) Leaves() *Set { … } type setNode … type SetNodeMap … type sortedSetNode … // Implement the sort interface; this would permit bulk creation, which would // be faster than doing it one at a time via Insert. func (s sortedSetNode) Len() int { … } func (s sortedSetNode) Less(i, j int) bool { … } func (s sortedSetNode) Swap(i, j int) { … } // Descend adds pe to the set if necessary, returning the associated subset. func (s *SetNodeMap) Descend(pe PathElement) *Set { … } // Size returns the sum of the number of members of all subsets. func (s *SetNodeMap) Size() int { … } // Empty returns false if there's at least one member in some child set. func (s *SetNodeMap) Empty() bool { … } // Get returns (the associated set, true) or (nil, false) if there is none. func (s *SetNodeMap) Get(pe PathElement) (*Set, bool) { … } // Equals returns true if s and s2 have the same structure (same nested // child sets). func (s *SetNodeMap) Equals(s2 *SetNodeMap) bool { … } // Union returns a SetNodeMap with members that appear in either s or s2. func (s *SetNodeMap) Union(s2 *SetNodeMap) *SetNodeMap { … } // Intersection returns a SetNodeMap with members that appear in both s and s2. func (s *SetNodeMap) Intersection(s2 *SetNodeMap) *SetNodeMap { … } // Difference returns a SetNodeMap with members that appear in s but not in s2. func (s *SetNodeMap) Difference(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) RecursiveDifference(s2 *Set) *SetNodeMap { … } // EnsureNamedFieldsAreMembers returns a set that contains all the named fields along with the leaves. func (s *SetNodeMap) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.TypeRef) *SetNodeMap { … } // FilterIncludeMatches returns a SetNodeMap with only the field paths that match the matcher. func (s *SetNodeMap) FilterIncludeMatches(pattern *SetMatcher) *SetNodeMap { … } // Iterate calls f for each PathElement in the set. func (s *SetNodeMap) Iterate(f func(PathElement)) { … } func (s *SetNodeMap) iteratePrefix(prefix Path, f func(Path)) { … } // Leaves returns a SetNodeMap containing // only setNodes with leaf PathElements. func (s *SetNodeMap) Leaves() *SetNodeMap { … } type Filter … // NewExcludeSetFilter returns a filter that removes field paths in the exclude set. func NewExcludeSetFilter(exclude *Set) Filter { … } // NewExcludeFilterSetMap converts a map of APIVersion to exclude set to a map of APIVersion to exclude filters. func NewExcludeFilterSetMap(resetFields map[APIVersion]*Set) map[APIVersion]Filter { … } type excludeFilter … func (t excludeFilter) Filter(set *Set) *Set { … } // NewIncludeMatcherFilter returns a filter that only includes field paths that match. // If no matchers are provided, the filter includes all field paths. // PrefixMatcher and MakePrefixMatcherOrDie can help create basic matcher. func NewIncludeMatcherFilter(matchers ...*SetMatcher) Filter { … } type includeMatcherFilter … func (pf includeMatcherFilter) Filter(set *Set) *Set { … }
Codebase Browser
kubernetes