var nativeObjTraitMask … var jsonValueType … var jsonStructType … // NativeTypes creates a type provider which uses reflect.Type and reflect.Value instances // to produce type definitions that can be used within CEL. // // All struct types in Go are exposed to CEL via their simple package name and struct type name: // // ```go // package identity // // type Account struct { // ID int // } // // ``` // // The type `identity.Account` would be exported to CEL using the same qualified name, e.g. // `identity.Account{ID: 1234}` would create a new `Account` instance with the `ID` field // populated. // // Only exported fields are exposed via NativeTypes, and the type-mapping between Go and CEL // is as follows: // // | Go type | CEL type | // |-------------------------------------|-----------| // | bool | bool | // | []byte | bytes | // | float32, float64 | double | // | int, int8, int16, int32, int64 | int | // | string | string | // | uint, uint8, uint16, uint32, uint64 | uint | // | time.Duration | duration | // | time.Time | timestamp | // | array, slice | list | // | map | map | // // Please note, if you intend to configure support for proto messages in addition to native // types, you will need to provide the protobuf types before the golang native types. The // same advice holds if you are using custom type adapters and type providers. The native type // provider composes over whichever type adapter and provider is configured in the cel.Env at // the time that it is invoked. // // There is also the possibility to rename the fields of native structs by setting the `cel` tag // for fields you want to override. In order to enable this feature, pass in the `EnableStructTag` // option. Here is an example to see it in action: // // ```go // package identity // // type Account struct { // ID int // OwnerName string `cel:"owner"` // } // // ``` // // The `OwnerName` field is now accessible in CEL via `owner`, e.g. `identity.Account{owner: 'bob'}`. // In case there are duplicated field names in the struct, an error will be returned. func NativeTypes(args ...any) cel.EnvOption { … } type NativeTypesOption … type nativeTypeOptions … // ParseStructTags configures if native types field names should be overridable by CEL struct tags. func ParseStructTags(enabled bool) NativeTypesOption { … } func newNativeTypeProvider(tpOptions nativeTypeOptions, adapter types.Adapter, provider types.Provider, refTypes ...any) (*nativeTypeProvider, error) { … } type nativeTypeProvider … // EnumValue proxies to the types.Provider configured at the times the NativeTypes // option was configured. func (tp *nativeTypeProvider) EnumValue(enumName string) ref.Val { … } // FindIdent looks up natives type instances by qualified identifier, and if not found // proxies to the composed types.Provider. func (tp *nativeTypeProvider) FindIdent(typeName string) (ref.Val, bool) { … } // FindStructType looks up the CEL type definition by qualified identifier, and if not found // proxies to the composed types.Provider. func (tp *nativeTypeProvider) FindStructType(typeName string) (*types.Type, bool) { … } func toFieldName(parseStructTag bool, f reflect.StructField) string { … } // FindStructFieldNames looks up the type definition first from the native types, then from // the backing provider type set. If found, a set of field names corresponding to the type // will be returned. func (tp *nativeTypeProvider) FindStructFieldNames(typeName string) ([]string, bool) { … } // valueFieldByName retrieves the corresponding reflect.Value field for the given field name, by // searching for a matching field tag value or field name. func valueFieldByName(parseStructTags bool, target reflect.Value, fieldName string) reflect.Value { … } // FindStructFieldType looks up a native type's field definition, and if the type name is not a native // type then proxies to the composed types.Provider func (tp *nativeTypeProvider) FindStructFieldType(typeName, fieldName string) (*types.FieldType, bool) { … } // NewValue implements the ref.TypeProvider interface method. func (tp *nativeTypeProvider) NewValue(typeName string, fields map[string]ref.Val) ref.Val { … } // NewValue adapts native values to CEL values and will proxy to the composed type adapter // for non-native types. func (tp *nativeTypeProvider) NativeToValue(val any) ref.Val { … } func convertToCelType(refType reflect.Type) (*cel.Type, bool) { … } func (tp *nativeTypeProvider) newNativeObject(val any, refValue reflect.Value) ref.Val { … } type nativeObj … // ConvertToNative implements the ref.Val interface method. // // CEL does not have a notion of pointers, so whether a field is a pointer or value // is handled as part of this conversion step. func (o *nativeObj) ConvertToNative(typeDesc reflect.Type) (any, error) { … } // ConvertToType implements the ref.Val interface method. func (o *nativeObj) ConvertToType(typeVal ref.Type) ref.Val { … } // Equal implements the ref.Val interface method. // // Note, that in Golang a pointer to a value is not equal to the value it contains. // In CEL pointers and values to which they point are equal. func (o *nativeObj) Equal(other ref.Val) ref.Val { … } // IsZeroValue indicates whether the contained Golang value is a zero value. // // Golang largely follows proto3 semantics for zero values. func (o *nativeObj) IsZeroValue() bool { … } // IsSet tests whether a field which is defined is set to a non-default value. func (o *nativeObj) IsSet(field ref.Val) ref.Val { … } // Get returns the value fo a field name. func (o *nativeObj) Get(field ref.Val) ref.Val { … } func (o *nativeObj) getReflectedField(field ref.Val) (reflect.Value, ref.Val) { … } // Type implements the ref.Val interface method. func (o *nativeObj) Type() ref.Type { … } // Value implements the ref.Val interface method. func (o *nativeObj) Value() any { … } func newNativeTypes(parseStructTags bool, rawType reflect.Type) ([]*nativeType, error) { … } var errDuplicatedFieldName … func newNativeType(parseStructTags bool, rawType reflect.Type) (*nativeType, error) { … } type nativeType … // ConvertToNative implements ref.Val.ConvertToNative. func (t *nativeType) ConvertToNative(typeDesc reflect.Type) (any, error) { … } // ConvertToType implements ref.Val.ConvertToType. func (t *nativeType) ConvertToType(typeVal ref.Type) ref.Val { … } // Equal returns true of both type names are equal to each other. func (t *nativeType) Equal(other ref.Val) ref.Val { … } // HasTrait implements the ref.Type interface method. func (t *nativeType) HasTrait(trait int) bool { … } // String implements the strings.Stringer interface method. func (t *nativeType) String() string { … } // Type implements the ref.Val interface method. func (t *nativeType) Type() ref.Type { … } // TypeName implements the ref.Type interface method. func (t *nativeType) TypeName() string { … } // Value implements the ref.Val interface method. func (t *nativeType) Value() any { … } // fieldByName returns the corresponding reflect.StructField for the give name either by matching // field tag or field name. func (t *nativeType) fieldByName(fieldName string) (reflect.StructField, bool) { … } // hasField returns whether a field name has a corresponding Golang reflect.StructField func (t *nativeType) hasField(fieldName string) (reflect.StructField, bool) { … } func adaptFieldValue(adapter types.Adapter, refField reflect.Value) ref.Val { … } func getFieldValue(refField reflect.Value) any { … } func simplePkgAlias(pkgPath string) string { … } func isValidObjectType(refType reflect.Type) bool { … } func isSupportedType(refType reflect.Type) bool { … } var pbMsgInterfaceType … var timestampType … var durationType …
Codebase Browser
kubernetes