kubernetes/vendor/github.com/google/cel-go/common/types/unknown.go

var unspecifiedAttribute …

// NewAttributeTrail creates a new simple attribute from a variable name.
func NewAttributeTrail(variable string) *AttributeTrail { … }

type AttributeTrail …

// Equal returns whether two attribute values have the same variable name and qualifier paths.
func (a *AttributeTrail) Equal(other *AttributeTrail) bool { … }

func qualifiersEqual(a, b any) bool { … }

func intUintEqual(i int64, u uint64) bool { … }

// Variable returns the variable name associated with the attribute.
func (a *AttributeTrail) Variable() string { … }

// QualifierPath returns the optional set of qualifying fields or indices applied to the variable.
func (a *AttributeTrail) QualifierPath() []any { … }

// String returns the string representation of the Attribute.
func (a *AttributeTrail) String() string { … }

func isIdentifierCharacter(str string) bool { … }

type AttributeQualifier …

// QualifyAttribute qualifies an attribute using a valid AttributeQualifier type.
func QualifyAttribute[T AttributeQualifier](attr *AttributeTrail, qualifier T) *AttributeTrail { … }

type Unknown …

// NewUnknown creates a new unknown at a given expression id for an attribute.
//
// If the attribute is nil, the attribute value will be the `unspecifiedAttribute`.
func NewUnknown(id int64, attr *AttributeTrail) *Unknown { … }

// IDs returns the set of unknown expression ids contained by this value.
//
// Numeric identifiers are guaranteed to be in sorted order.
func (u *Unknown) IDs() []int64 { … }

// GetAttributeTrails returns the attribute trails, if present, missing for a given expression id.
func (u *Unknown) GetAttributeTrails(id int64) ([]*AttributeTrail, bool) { … }

// Contains returns true if the input unknown is a subset of the current unknown.
func (u *Unknown) Contains(other *Unknown) bool { … }

// ConvertToNative implements ref.Val.ConvertToNative.
func (u *Unknown) ConvertToNative(typeDesc reflect.Type) (any, error) { … }

// ConvertToType is an identity function since unknown values cannot be modified.
func (u *Unknown) ConvertToType(typeVal ref.Type) ref.Val { … }

// Equal is an identity function since unknown values cannot be modified.
func (u *Unknown) Equal(other ref.Val) ref.Val { … }

// String implements the Stringer interface
func (u *Unknown) String() string { … }

// Type implements ref.Val.Type.
func (u *Unknown) Type() ref.Type { … }

// Value implements ref.Val.Value.
func (u *Unknown) Value() any { … }

// IsUnknown returns whether the element ref.Val is in instance of *types.Unknown
func IsUnknown(val ref.Val) bool { … }

// MaybeMergeUnknowns determines whether an input value and another, possibly nil, unknown will produce
// an unknown result.
//
// If the input `val` is another Unknown, then the result will be the merge of the `val` and the input
// `unk`. If the `val` is not unknown, then the result will depend on whether the input `unk` is nil.
// If both values are non-nil and unknown, then the return value will be a merge of both unknowns.
func MaybeMergeUnknowns(val ref.Val, unk *Unknown) (*Unknown, bool) { … }

// MergeUnknowns combines two unknown values into a new unknown value.
func MergeUnknowns(unk1, unk2 *Unknown) *Unknown { … }

type int64Slice …

// Len returns the number of elements in the slice.
func (x int64Slice) Len() int { … }

// Less indicates whether the value at index i is less than the value at index j.
func (x int64Slice) Less(i, j int) bool { … }

// Swap swaps the values at indices i and j in place.
func (x int64Slice) Swap(i, j int) { … }

// Sort is a convenience method: x.Sort() calls Sort(x).
func (x int64Slice) Sort() { … }