Enum CedarValueJson

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

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 __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

The __expr escape has been removed, but is still reserved in order to throw meaningful errors.

Fields

__expr: SmolStr

Contents, will be ignored and an error is thrown when attempting to parse this

EntityEscape

Special JSON object with single reserved “__entity” key: the following item should be a JSON object of the form { "type": "xxx", "id": "yyy" }. This escape 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" }. This escape 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<CedarValueJson>)

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

Record(JsonRecord)

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

Null

JSON null, which is never valid, but we put this here in order to provide a better error message.

Implementations

impl CedarValueJson

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

Encode the given EntityUID as a CedarValueJson

pub fn into_expr( self, ctx: impl Fn() -> JsonDeserializationErrorContext + Clone, ) -> Result<RestrictedExpr, JsonDeserializationError>

Convert this CedarValueJson into a Cedar “restricted expression”

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

Convert a Cedar “restricted expression” into a CedarValueJson.

pub fn from_value(value: Value) -> Result<Self, JsonSerializationError>

Convert a Cedar value into a CedarValueJson.

Only throws errors in two cases:

1. value is (or contains) a record with a reserved key such as “__entity”
2. value is (or contains) an extension value, and the argument to the extension constructor that produced that extension value can’t itself be converted to CedarJsonValue. (Either because that argument falls into one of these two cases itself, or because the argument is a nontrivial residual.)

pub fn from_valuekind(value: ValueKind) -> Result<Self, JsonSerializationError>

Convert a Cedar ValueKind into a CedarValueJson.

For discussion of when this throws errors, see notes on from_value.

pub fn from_lit(lit: Literal) -> Self

Convert a Cedar literal into a CedarValueJson.

pub fn sub_entity_literals( self, mapping: &BTreeMap<EntityUID, EntityUID>, ) -> Result<Self, JsonDeserializationError>

Substitute entity literals

Trait Implementations

impl Clone for CedarValueJson

fn clone(&self) -> CedarValueJson

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CedarValueJson

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CedarValueJson

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CedarValueJson

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

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 CedarValueJson

impl StructuralPartialEq for CedarValueJson