Enum cedar_policy_core::est::ExprNoExt

pub enum ExprNoExt {
    Value(JSONValue),
    Var(Var),
    Slot(SlotId),
    Unknown {
        name: SmolStr,
    },
    Not {
        arg: Arc<Expr>,
    },
    Neg {
        arg: Arc<Expr>,
    },
    Eq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    NotEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    In {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Less {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    LessEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Greater {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    GreaterEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    And {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Or {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Add {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Sub {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Mul {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Contains {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    ContainsAll {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    ContainsAny {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    GetAttr {
        left: Arc<Expr>,
        attr: SmolStr,
    },
    HasAttr {
        left: Arc<Expr>,
        attr: SmolStr,
    },
    Like {
        left: Arc<Expr>,
        pattern: SmolStr,
    },
    If {
        cond_expr: Arc<Expr>,
        then_expr: Arc<Expr>,
        else_expr: Arc<Expr>,
    },
    Set(Vec<Expr>),
    Record(HashMap<SmolStr, Expr>),
}

Serde JSON structure for [any Cedar expression other than an extension function call] in the EST format

Variants

Value(JSONValue)

Literal value (including anything that’s legal to express in the attribute-value JSON format)

Var(Var)

Var

Slot(SlotId)

Template slot

Unknown

Unknown (for partial evaluation)

Fields

name: SmolStr

Name of the unknown

Not

!

Fields

arg: Arc<Expr>

Argument

Neg

-

Fields

arg: Arc<Expr>

Argument

Eq

==

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

NotEq

!=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

In

in

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Less

<

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

LessEq

<=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Greater

>

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

GreaterEq

>=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

And

&&

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Or

||

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Add

+

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Sub

-

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Mul

*

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Contains

contains()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

ContainsAll

containsAll()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

ContainsAny

containsAny()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

GetAttr

Get-attribute

Fields

left: Arc<Expr>

Left-hand argument

attr: SmolStr

Attribute name

HasAttr

has

Fields

left: Arc<Expr>

Left-hand argument

attr: SmolStr

Attribute name

Like

like

Fields

left: Arc<Expr>

Left-hand argument

pattern: SmolStr

Pattern

If

Ternary

Fields

cond_expr: Arc<Expr>

Condition

then_expr: Arc<Expr>

then expression

else_expr: Arc<Expr>

else expression

Set(Vec<Expr>)

Set literal, whose elements may be arbitrary expressions (which is why we need this case specifically and can’t just use Expr::Value)

Record(HashMap<SmolStr, Expr>)

Record literal, whose elements may be arbitrary expressions (which is why we need this case specifically and can’t just use Expr::Value)

Trait Implementations

impl Clone for ExprNoExt

fn clone(&self) -> ExprNoExt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprNoExt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprNoExt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExprNoExt

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExprNoExt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExprNoExt