Enum JsonDeserializationError 

pub enum JsonDeserializationError {
    Serde(Error),
    ExprParseError(ParseError),
    EntityParseError(ParseError),
    ExtnParseError(ParseError),
    RestrictedExpressionError(RestrictedExpressionError),
    ExtensionsError(ExtensionsError),
    ExpectedLiteralEntityRef {
        ctx: JsonDeserializationErrorContext,
        got: Box<Expr>,
    },
    ExpectedExtnValue {
        ctx: JsonDeserializationErrorContext,
        got: Box<Expr>,
    },
    ExpectedContextToBeRecord {
        got: Box<RestrictedExpr>,
    },
    ImpliedConstructorNotFound {
        return_type: Box<SchemaType>,
        arg_type: Box<SchemaType>,
    },
    UnexpectedEntityAttr {
        uid: EntityUID,
        attr: SmolStr,
    },
    UnexpectedRecordAttr {
        ctx: JsonDeserializationErrorContext,
        record_attr: SmolStr,
    },
    MissingRequiredEntityAttr {
        uid: EntityUID,
        attr: SmolStr,
    },
    MissingRequiredRecordAttr {
        ctx: JsonDeserializationErrorContext,
        record_attr: SmolStr,
    },
    TypeMismatch {
        ctx: JsonDeserializationErrorContext,
        expected: Box<SchemaType>,
        actual: Box<SchemaType>,
    },
    HeterogeneousSet {
        ctx: JsonDeserializationErrorContext,
        ty1: Box<SchemaType>,
        ty2: Box<SchemaType>,
    },
}

Errors thrown during deserialization from JSON

Variants

Serde(Error)

Error thrown by serde_json

ExprParseError(ParseError)

Contents of an __expr escape failed to parse as a Cedar expression.

__expr is deprecated (starting with the 1.2 release), and once it is removed, this error will also be removed.

EntityParseError(ParseError)

Contents of an __entity escape failed to parse as an entity reference

ExtnParseError(ParseError)

Function name in an __extn escape failed to parse as an extension function name

RestrictedExpressionError(RestrictedExpressionError)

Restricted expression error

ExtensionsError(ExtensionsError)

Error thrown by an operation on Extensions

ExpectedLiteralEntityRef

A field that needs to be a literal entity reference, was some other JSON value

Fields

ctx: JsonDeserializationErrorContext

Context of this error

got: Box<Expr>

the expression we got instead

ExpectedExtnValue

A field that needs to be an extension value, was some other JSON value

Fields

ctx: JsonDeserializationErrorContext

Context of this error

got: Box<Expr>

the expression we got instead

ExpectedContextToBeRecord

Contexts need to be records, but we got some other JSON value

Fields

got: Box<RestrictedExpr>

Expression we got instead

ImpliedConstructorNotFound

Schema-based parsing needed an implicit extension constructor, but no suitable constructor was found

Fields

return_type: Box<SchemaType>

return type of the constructor we were looking for

arg_type: Box<SchemaType>

argument type of the constructor we were looking for

UnexpectedEntityAttr

During schema-based parsing, encountered this attribute on this entity, but that attribute shouldn’t exist on entities of this type

Fields

uid: EntityUID

Entity that had the unexpected attribute

attr: SmolStr

Name of the attribute that was unexpected

UnexpectedRecordAttr

During schema-based parsing, encountered this attribute on a record, but that attribute shouldn’t exist on that record

Fields

ctx: JsonDeserializationErrorContext

Context of this error

record_attr: SmolStr

Name of the (Record) attribute which was unexpected

MissingRequiredEntityAttr

During schema-based parsing, didn’t encounter this attribute of a record, but that attribute should have existed

Fields

uid: EntityUID

Entity that is missing a required attribute

attr: SmolStr

Name of the attribute which was expected

MissingRequiredRecordAttr

During schema-based parsing, didn’t encounter this attribute of a record, but that attribute should have existed

Fields

ctx: JsonDeserializationErrorContext

Context of this error

record_attr: SmolStr

Name of the (Record) attribute which was expected

TypeMismatch

During schema-based parsing, the given attribute on the given entity had a different type than the schema indicated to expect

Fields

ctx: JsonDeserializationErrorContext

Context of this error

expected: Box<SchemaType>

Type which was expected

actual: Box<SchemaType>

Type which was encountered instead

HeterogeneousSet

During schema-based parsing, found a set whose elements don’t all have the same type. This doesn’t match any possible schema.

Fields

ctx: JsonDeserializationErrorContext

Context of this error

ty1: Box<SchemaType>

First element type which was found

ty2: Box<SchemaType>

Second element type which was found

Trait Implementations

impl Debug for JsonDeserializationError

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

Formats the value using the given formatter.

impl Display for JsonDeserializationError

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

Formats the value using the given formatter.

impl Error for JsonDeserializationError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for JsonDeserializationError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ExtensionsError> for JsonDeserializationError

fn from(source: ExtensionsError) -> Self

Converts to this type from the input type.

impl From<JsonDeserializationError> for EntitiesError

fn from(source: JsonDeserializationError) -> Self

Converts to this type from the input type.

impl From<JsonDeserializationError> for EstToAstError

fn from(source: JsonDeserializationError) -> Self

Converts to this type from the input type.

impl From<RestrictedExpressionError> for JsonDeserializationError

fn from(source: RestrictedExpressionError) -> Self

Converts to this type from the input type.