Struct cedar_policy_core::ast::BorrowedRestrictedExpr

pub struct BorrowedRestrictedExpr<'a>(/* private fields */);

While RestrictedExpr wraps an owned Expr, BorrowedRestrictedExpr wraps a borrowed Expr, with the same invariants.

Implementations

impl<'a> BorrowedRestrictedExpr<'a>

pub fn new(expr: &'a Expr) -> Result<Self, RestrictedExpressionError>

Create a new BorrowedRestrictedExpr from an &Expr.

This function is “safe” in the sense that it will verify that the provided expr does indeed qualify as a “restricted” expression, returning an error if not.

Note this check requires recursively walking the AST. For a version of this function that doesn’t perform this check, see new_unchecked() below.

pub fn new_unchecked(expr: &'a Expr) -> Self

Create a new BorrowedRestrictedExpr from an &Expr, where the caller is responsible for ensuring that the Expr is a valid “restricted expression”. If it is not, internal invariants will be violated, which may lead to other errors later, panics, or even incorrect results.

For a “safer” version of this function that returns an error for invalid inputs, see new() above.

pub fn to_natural_json(self) -> Result<Value, JsonSerializationError>

Write a BorrowedRestrictedExpr in “natural JSON” format.

Used to output the context as a map from Strings to JSON Values

Methods from Deref<Target = Expr>

pub fn expr_kind(&self) -> &ExprKind<T>

Access the inner ExprKind for this Expr. The ExprKind is the enum which specifies the expression variant, so it must be accessed by any code matching and recursing on an expression.

pub fn data(&self) -> &T

Access the data stored on the Expr.

pub fn source_info(&self) -> &Option<SourceInfo>

Access the data stored on the Expr.

pub fn is_ref(&self) -> bool

Check whether this expression is an entity reference

This is used for policy headers, where some syntax is required to be an entity reference.

pub fn is_slot(&self) -> bool

Check whether this expression is a slot.

pub fn is_ref_set(&self) -> bool

Check whether this expression is a set of entity references

This is used for policy headers, where some syntax is required to be an entity reference set.

pub fn subexpressions(&self) -> impl Iterator<Item = &Self>

Iterate over all sub-expressions in this expression

pub fn slots(&self) -> impl Iterator<Item = &SlotId>

Iterate over all of the slots in this policy AST

pub fn is_projectable(&self) -> bool

Determine if the expression is projectable under partial evaluation An expression is projectable if it’s guaranteed to never error on evaluation This is true if the expression is entirely composed of values or unknowns

pub fn is_unknown(&self) -> bool

Check if an expression contains any symbolic unknowns

pub fn unknowns(&self) -> impl Iterator<Item = &str>

Get all unknowns in an expression

pub fn substitute( &self, definitions: &HashMap<SmolStr, Value>, ) -> Result<Expr, SubstitutionError>

Substitute unknowns with values If a definition is missing, it will be left as an unknown, and can be filled in later.

pub fn eq_shape<U>(&self, other: &Expr<U>) -> bool

Return true if this expression (recursively) has the same expression kind as the argument expression. This accounts for the full recursive shape of the expression, but does not consider source information or any generic data annotated on expression. This should behave the same as the default implementation of Eq before source information and generic data were added.

pub fn hash_shape<H>(&self, state: &mut H)

where H: Hasher,

Implementation of hashing corresponding to equality as implemented by eq_shape. Must satisfy the usual relationship between equality and hashing.

Trait Implementations

impl<'a> AsRef<Expr> for BorrowedRestrictedExpr<'a>

fn as_ref(&self) -> &'a Expr

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for BorrowedRestrictedExpr<'a>

fn clone(&self) -> BorrowedRestrictedExpr<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BorrowedRestrictedExpr<'a>

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

Formats the value using the given formatter.

impl<'a> Display for BorrowedRestrictedExpr<'a>

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

Formats the value using the given formatter.

impl<'a> From<BorrowedRestrictedExpr<'a>> for &'a Expr

fn from(r: BorrowedRestrictedExpr<'a>) -> &'a Expr

Converts to this type from the input type.

impl<'a> Hash for BorrowedRestrictedExpr<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for BorrowedRestrictedExpr<'a>

fn eq(&self, other: &BorrowedRestrictedExpr<'a>) -> 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<'a> Serialize for BorrowedRestrictedExpr<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Deref for BorrowedRestrictedExpr<'a>

type Target = Expr

The resulting type after dereferencing.

fn deref(&self) -> &'a Expr

Dereferences the value.

impl<'a> Eq for BorrowedRestrictedExpr<'a>

impl<'a> StructuralPartialEq for BorrowedRestrictedExpr<'a>