Enum cedar_policy_core::entities::JSONValue

pub enum JSONValue {
    ExprEscape {
        __expr: SmolStr,
    },
    EntityEscape {
        __entity: TypeAndId,
    },
    ExtnEscape {
        __extn: FnAndArg,
    },
    Bool(bool),
    Long(i64),
    String(SmolStr),
    Set(Vec<JSONValue>),
    Record(HashMap<SmolStr, JSONValue>),
}

The canonical JSON representation of a Cedar value. Many Cedar values have a natural one-to-one mapping to and from JSON values. Cedar values of some types, like entity references or extension values, cannot easily be represented in JSON and thus are represented using the __expr, __entity, or __extn escapes.

For example, this is the JSON format for attribute values expected by EntityJsonParser, when schema-based parsing is not used.

Variants

ExprEscape

Special JSON object with single reserved “__expr” key: interpret the following string as a (restricted) Cedar expression. Some escape (this or the following ones) is necessary for extension values and entity references, but this __expr escape could also be used for any other values.

__expr is deprecated (starting with the 1.2 release) and will be removed in favor of __entity and __extn, which together cover all of the use-cases where __expr would have been necessary.

Fields

__expr: SmolStr

String to interpret as a (restricted) Cedar expression

EntityEscape

Special JSON object with single reserved “__entity” key: the following item should be a JSON object of the form { "type": "xxx", "id": "yyy" }. Some escape (this or __expr, which is deprecated) is necessary for entity references.

Fields

__entity: TypeAndId

JSON object containing the entity type and ID

ExtnEscape

Special JSON object with single reserved “__extn” key: the following item should be a JSON object of the form { "fn": "xxx", "arg": "yyy" }. Some escape (this or __expr, which is deprecated) is necessary for extension values.

Fields

__extn: FnAndArg

JSON object containing the extension-constructor call

Bool(bool)

JSON bool => Cedar bool

Long(i64)

JSON int => Cedar long (64-bit signed integer)

String(SmolStr)

JSON string => Cedar string

Set(Vec<JSONValue>)

JSON list => Cedar set; can contain any JSONValues, even heterogeneously

Record(HashMap<SmolStr, JSONValue>)

JSON object => Cedar record; must have string keys, but values can be any JSONValues, even heterogeneously

Implementations

impl JSONValue

pub fn uid(euid: &EntityUID) -> Self

Encode the given EntityUID as a JSONValue

pub fn into_expr(self) -> Result<RestrictedExpr, JsonDeserializationError>

Convert this JSONValue into a Cedar “restricted expression”

pub fn from_expr( expr: BorrowedRestrictedExpr<'_>, ) -> Result<Self, JsonSerializationError>

Convert a Cedar “restricted expression” into a JSONValue.

pub fn from_lit(lit: Literal) -> Self

Convert a Cedar literal into a JSONValue.

Trait Implementations

impl Clone for JSONValue

fn clone(&self) -> JSONValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JSONValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for JSONValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for JSONValue

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for JSONValue

impl StructuralPartialEq for JSONValue