Enum cedar_policy_core::est::Expr

pub enum Expr {
    ExprNoExt(ExprNoExt),
    ExtFuncCall(ExtFuncCall),
}

Serde JSON structure for a Cedar expression in the EST format

Variants

ExprNoExt(ExprNoExt)

Any Cedar expression other than an extension function call. We try to match this first, see docs on #[serde(untagged)].

ExtFuncCall(ExtFuncCall)

If that didn’t match (because the key is not one of the keys defined in ExprNoExt), we assume we have an extension function call, where the key is the name of an extension function or method.

Implementations

impl Expr

pub fn lit(lit: JSONValue) -> Self

literal

pub fn var(var: Var) -> Self

principal, action, resource, context

pub fn slot(slot: SlotId) -> Self

Template slots

pub fn unknown(name: impl Into<SmolStr>) -> Self

Partial-evaluation unknowns

pub fn not(e: Expr) -> Self

!

pub fn neg(e: Expr) -> Self

-

pub fn eq(left: Expr, right: Expr) -> Self

==

pub fn noteq(left: Expr, right: Expr) -> Self

!=

pub fn _in(left: Expr, right: Expr) -> Self

in

pub fn less(left: Expr, right: Expr) -> Self

<

pub fn lesseq(left: Expr, right: Expr) -> Self

<=

pub fn greater(left: Expr, right: Expr) -> Self

>

pub fn greatereq(left: Expr, right: Expr) -> Self

>=

pub fn and(left: Expr, right: Expr) -> Self

&&

pub fn or(left: Expr, right: Expr) -> Self

||

pub fn add(left: Expr, right: Expr) -> Self

+

pub fn sub(left: Expr, right: Expr) -> Self

-

pub fn mul(left: Expr, right: Expr) -> Self

*

pub fn contains(left: Arc<Expr>, right: Expr) -> Self

left.contains(right)

pub fn contains_all(left: Arc<Expr>, right: Expr) -> Self

left.containsAll(right)

pub fn contains_any(left: Arc<Expr>, right: Expr) -> Self

left.containsAny(right)

pub fn get_attr(left: Expr, attr: SmolStr) -> Self

left.attr

pub fn has_attr(left: Expr, attr: SmolStr) -> Self

left has attr

pub fn like(left: Expr, pattern: SmolStr) -> Self

left like pattern

pub fn ite(cond_expr: Expr, then_expr: Expr, else_expr: Expr) -> Self

if cond_expr then then_expr else else_expr

pub fn set(elements: Vec<Expr>) -> Self

e.g. [1+2, !(context has department)]

pub fn record(map: HashMap<SmolStr, Expr>) -> Self

e.g. {foo: 1+2, bar: !(context has department)}

pub fn ext_call(fn_name: SmolStr, args: Vec<Expr>) -> Self

extension function call, including method calls

pub fn into_string_literal(self) -> Option<SmolStr>

Consume the Expr, producing a string literal if it was a string literal, otherwise None

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Expr> for Expr

fn from(expr: Expr) -> Expr

Converts to this type from the input type.

impl From<Literal> for Expr

fn from(lit: Literal) -> Expr

Converts to this type from the input type.

impl From<SlotId> for Expr

fn from(slot: SlotId) -> Expr

Converts to this type from the input type.

impl From<Var> for Expr

fn from(var: Var) -> Expr

Converts to this type from the input type.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> 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 Expr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Add> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(a: Add) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<And> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(a: And) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Expr> for Expr

type Error = EstToAstError

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Expr, EstToAstError>

Performs the conversion.

impl TryFrom<Expr> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(e: Expr) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Literal> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(lit: Literal) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Member> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(m: Member) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Mult> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(m: Mult) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Name> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(name: Name) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Or> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(o: Or) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Relation> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(r: Relation) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<Unary> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(u: Unary) -> Result<Expr, ParseErrors>

Performs the conversion.

impl StructuralPartialEq for Expr