expr

Documentation

Index

• Constants
• func FuncMap() map[string]FuncBase
• type AttributeDescriptorFinder
• type Constant
  • func (c *Constant) String() string
• type Evaluator
  • func NewCEXLEvaluator(cacheSize int) (Evaluator, error)
• type Expression
  • func Parse(src string) (ex *Expression, err error)
  • func (e *Expression) Eval(attrs attribute.Bag, fMap map[string]FuncBase) (interface{}, error)
  • func (e *Expression) EvalType(attrs AttributeDescriptorFinder, fMap map[string]FuncBase) (valueType dpb.ValueType, err error)
  • func (e *Expression) String() string
• type Func
• type FuncBase
• type Function
  • func (f *Function) EvalType(attrs AttributeDescriptorFinder, fMap map[string]FuncBase) (valueType dpb.ValueType, err error)
  • func (f *Function) String() string
• type PredicateEvaluator
• type TypeChecker
• type Variable
  • func (v *Variable) Eval(attrs attribute.Bag) (interface{}, error)
  • func (v *Variable) String() string

Constants

const DefaultCacheSize = 1024

DefaultCacheSize is the default size for the expression cache.

Functions

func FuncMap

func FuncMap() map[string]FuncBase

FuncMap provides inventory of available functions.

Types

type AttributeDescriptorFinder

type AttributeDescriptorFinder interface {
	// GetAttribute finds attribute descriptor in the vocabulary. returns nil if not found.
	GetAttribute(name string) *cfgpb.AttributeManifest_AttributeInfo
}

AttributeDescriptorFinder finds attribute descriptors.

type Constant

type Constant struct {
	StrValue string
	Value    interface{}
	Type     dpb.ValueType
}

Constant models a typed constant.

func (*Constant) String

func (c *Constant) String() string

type Evaluator

type Evaluator interface {
	// Eval evaluates given expression using the attribute bag
	Eval(expr string, attrs attribute.Bag) (interface{}, error)

	// Eval evaluates given expression using the attribute bag to a string
	EvalString(expr string, attrs attribute.Bag) (string, error)

	PredicateEvaluator

	TypeChecker
}

Evaluator evaluates an expression written in the implementation defined expression language. It uses attribute.Bag as variable bindings.

func NewCEXLEvaluator

func NewCEXLEvaluator(cacheSize int) (Evaluator, error)

NewCEXLEvaluator returns a new Evaluator of this type.

type Expression

type Expression struct {
	// Oneof the following
	Const *Constant
	Var   *Variable
	Fn    *Function
}

Expression is a simplified expression AST

func Parse

func Parse(src string) (ex *Expression, err error)

Parse parses a given expression to ast.Expression.

func (*Expression) Eval

func (e *Expression) Eval(attrs attribute.Bag, fMap map[string]FuncBase) (interface{}, error)

Eval evaluates the expression given an attribute bag and a function map.

func (*Expression) EvalType

func (e *Expression) EvalType(attrs AttributeDescriptorFinder, fMap map[string]FuncBase) (valueType dpb.ValueType, err error)

EvalType Function an expression using fMap and attribute vocabulary. Returns the type that this expression evaluates to.

func (*Expression) String

func (e *Expression) String() string

String produces postfix version with all operators converted to function names

type Func

type Func interface {
	FuncBase

	// Call performs the function call. It is guaranteed
	// that call will be made with correct arity.
	// may panic.
	Call(attrs attribute.Bag, args []*Expression, fMap map[string]FuncBase) (interface{}, error)
}

Func implements a function call. It needs to know details about Expressions and attribute bag.

type FuncBase

type FuncBase interface {
	// Name uniquely identifies the function.
	Name() string

	// ReturnType specifies the return type of this function.
	ReturnType() config.ValueType

	// ArgTypes specifies the argument types in order expected by the function.
	ArgTypes() []config.ValueType
}

FuncBase defines the interface that every expression function must implement.

type Function

type Function struct {
	Name string
	Args []*Expression
}

Function models a function with multiple parameters 1st arg can be thought of as the receiver.

func (*Function) EvalType

func (f *Function) EvalType(attrs AttributeDescriptorFinder, fMap map[string]FuncBase) (valueType dpb.ValueType, err error)

EvalType Function using fMap and attribute vocabulary. Return static or computed return type if all args have correct type.

func (*Function) String

func (f *Function) String() string

type PredicateEvaluator

type PredicateEvaluator interface {
	// EvalPredicate evaluates given predicate using the attribute bag
	EvalPredicate(expr string, attrs attribute.Bag) (bool, error)
}

PredicateEvaluator evaluates a predicate to true or false

type TypeChecker

type TypeChecker interface {
	// EvalType produces the type of an expression or an error if the type cannot be evaluated.
	// TODO: we probably want to use a golang type rather than pb.ValueType (a proto).
	EvalType(expr string, finder AttributeDescriptorFinder) (pb.ValueType, error)

	// AssertType evaluates the type of expr using the attribute set; if the evaluated type is equal to
	// the expected type we return nil, and return an error otherwise.
	AssertType(expr string, finder AttributeDescriptorFinder, expectedType pb.ValueType) error
}

TypeChecker validates a given expression for type safety.

type Variable

type Variable struct {
	Name string
}

Variable models a variable.

func (*Variable) Eval

func (v *Variable) Eval(attrs attribute.Bag) (interface{}, error)

Eval returns value of the contained variable or error

func (*Variable) String

func (v *Variable) String() string