Struct googapis::google::api::expr::v1alpha1::expr::Comprehension

pub struct Comprehension {
    pub iter_var: String,
    pub iter_range: Option<Box<Expr>>,
    pub accu_var: String,
    pub accu_init: Option<Box<Expr>>,
    pub loop_condition: Option<Box<Expr>>,
    pub loop_step: Option<Box<Expr>>,
    pub result: Option<Box<Expr>>,
}

A comprehension expression applied to a list or map.

Comprehensions are not part of the core syntax, but enabled with macros. A macro matches a specific call signature within a parsed AST and replaces the call with an alternate AST block. Macro expansion happens at parse time.

The following macros are supported within CEL:

Aggregate type macros may be applied to all elements in a list or all keys in a map:

• all, exists, exists_one - test a predicate expression against the inputs and return true if the predicate is satisfied for all, any, or only one value list.all(x, x < 10).
• filter - test a predicate expression against the inputs and return the subset of elements which satisfy the predicate: payments.filter(p, p > 1000).
• map - apply an expression to all elements in the input and return the output aggregate type: [1, 2, 3].map(i, i * i).

The has(m.x) macro tests whether the property x is present in struct m. The semantics of this macro depend on the type of m. For proto2 messages has(m.x) is defined as ’defined, but not set. For proto3, the macro tests whether the property is set to its default. For map and struct types, the macro tests whether the property xis defined onm`.

Fields

iter_var: String

The name of the iteration variable.

iter_range: Option<Box<Expr>>

The range over which var iterates.

accu_var: String

The name of the variable used for accumulation of the result.

accu_init: Option<Box<Expr>>

The initial value of the accumulator.

loop_condition: Option<Box<Expr>>

An expression which can contain iter_var and accu_var.

Returns false when the result has been computed and may be used as a hint to short-circuit the remainder of the comprehension.

loop_step: Option<Box<Expr>>

An expression which can contain iter_var and accu_var.

Computes the next value of accu_var.

result: Option<Box<Expr>>

An expression which can contain accu_var.

Computes the result.

Trait Implementations

impl Clone for Comprehension

fn clone(&self) -> Comprehension

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Comprehension

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Comprehension

fn default() -> Self

Returns the “default value” for a type.

impl Message for Comprehension

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8, Global>

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8, Global>

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Comprehension> for Comprehension

fn eq(&self, other: &Comprehension) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Comprehension) -> bool

This method tests for !=.

impl StructuralPartialEq for Comprehension