Enum Save

pub enum Save<'a, E = Infallible> {
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    I128(i128),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    U128(u128),
    F32(f32),
    F64(f64),
    Char(char),
    String(String),
    ByteArray(Vec<u8>),
    Option(Option<Box<Self>>),
    Unit,
    UnitStruct(&'a str),
    UnitVariant(Variant<'a>),
    NewTypeStruct {
        name: &'a str,
        value: Box<Self>,
    },
    NewTypeVariant {
        variant: Variant<'a>,
        value: Box<Self>,
    },
    Seq(Vec<Self>),
    Map(Vec<(Self, Self)>),
    Tuple(Vec<Self>),
    TupleStruct {
        name: &'a str,
        values: Vec<Self>,
    },
    TupleVariant {
        variant: Variant<'a>,
        values: Vec<Self>,
    },
    Struct {
        name: &'a str,
        fields: Vec<(&'a str, Option<Self>)>,
    },
    StructVariant {
        variant: Variant<'a>,
        fields: Vec<(&'a str, Option<Self>)>,
    },
    Error(E),
}

A complete serde serialization tree.

Accepts a lifetime to allow users to write dynamic tests.

See crate documentation for more.

Variants

Bool(bool)

Primitive type, from a call to serde::Serializer::serialize_bool.

I8(i8)

Primitive type, from a call to serde::Serializer::serialize_i8.

I16(i16)

Primitive type, from a call to serde::Serializer::serialize_i16.

I32(i32)

Primitive type, from a call to serde::Serializer::serialize_i32.

I64(i64)

Primitive type, from a call to serde::Serializer::serialize_i64.

I128(i128)

Primitive type, from a call to serde::Serializer::serialize_i128.

U8(u8)

Primitive type, from a call to serde::Serializer::serialize_u8.

U16(u16)

Primitive type, from a call to serde::Serializer::serialize_u16.

U32(u32)

Primitive type, from a call to serde::Serializer::serialize_u32.

U64(u64)

Primitive type, from a call to serde::Serializer::serialize_u64.

U128(u128)

Primitive type, from a call to serde::Serializer::serialize_u128.

F32(f32)

Primitive type, from a call to serde::Serializer::serialize_f32.

F64(f64)

Primitive type, from a call to serde::Serializer::serialize_f64.

Char(char)

Primitive type, from a call to serde::Serializer::serialize_char.

String(String)

A call to serde::Serializer::serialize_str.

ByteArray(Vec<u8>)

A call to serde::Serializer::serialize_bytes.

Option(Option<Box<Self>>)

A call to serde::Serializer::serialize_some or serde::Serializer::serialize_none.

Unit

The empty tuple, from a call to serde::Serializer::serialize_unit.

UnitStruct(&'a str)

A unit struct, from a call to serde::Serializer::serialize_unit_struct.

struct MyUnitStruct;

UnitVariant(Variant<'a>)

A unit variant of an enum, from a call to serde::Serializer::serialize_unit_variant.

enum MyEnum {
    MyUnitVariant,
    // ...
}

NewTypeStruct

A tuple struct with a single unnamed field, from a call to serde::Serializer::serialize_newtype_struct.

struct MyStruct(A);

Fields

name: &'a str

value: Box<Self>

NewTypeVariant

A tuple variant of an enum with a single unnamed field, from a call to serde::Serializer::serialize_newtype_variant.

enum MyEnum {
    MyNewTypeVariant(A),
    // ...
}

Fields

variant: Variant<'a>

value: Box<Self>

Seq(Vec<Self>)

A dynamic sequence of values, from a call to serde::Serializer::serialize_seq.

If protocol errors are enabled, checks that the number of items matches the length (if any) passed to the call to serialize_seq.

Map(Vec<(Self, Self)>)

A dynamic mapping between values, from a call to serde::Serializer::serialize_map.

If protocol errors are enabled, checks that the number of items matches the length (if any) passed to the call to serialize_map.

Note:

• Orphaned keys or values are always an error.
• Duplicate map keys are always allowed.

Tuple(Vec<Self>)

A fixed sequence of values, from a call to serde::Serializer::serialize_tuple.

(A, B, C);

If protocol errors are enabled, checks that the number of items matches the length passed to the call to serialize_tuple.

TupleStruct

A fixed sequence of unnamed fields in a struct, from a call to serde::Serializer::serialize_tuple_struct.

struct MyTupleStruct(A, B, C);

If protocol errors are enabled, checks that the number of items matches the length passed to the call to serialize_tuple_struct.

Fields

name: &'a str

values: Vec<Self>

TupleVariant

A fixed sequence of unnamed fields in an enum variant, from a call to serde::Serializer::serialize_tuple_variant.

enum MyEnum {
    MyTupleVariant(A, B, C),
    // ...
}

If protocol errors are enabled, checks that the number of items matches the length passed to the call to serialize_tuple_variant.

Fields

variant: Variant<'a>

values: Vec<Self>

Struct

A fixed mapping from field names to values in a struct, from a call to serde::Serializer::serialize_struct.

struct MyStruct {
    num_yaks: usize,
    shepherd_name: String,
}

If protocol errors are enabled, checks that:

• the number of items matches the length passed to the call to serialize_struct.
• all fields are unique

Fields

name: &'a str

fields: Vec<(&'a str, Option<Self>)>

RHS is None for skiped fields.

For in-tree errors, the field name is "!error".

StructVariant

A fixed mapping from named fields to values in an enum variant, from a call to serde::Serializer::serialize_struct_variant.

enum MyEnum {
    MyStructVariant {
        num_yaks: usize,
        shepherd_name: String,
    },
    // ...
}

If protocol errors are enabled, checks that:

• the number of items matches the length passed to the call to serialize_struct_variant.
• all fields are unique

Fields

variant: Variant<'a>

fields: Vec<(&'a str, Option<Self>)>

RHS is None for skiped fields.

For in-tree errors, the field name is "!error".

Error(E)

An in-tree persisted error.

Note that this is uninhabited by default, and you can prove it to be unreachable in your code:

fn stringify(save: Save) -> String {
    match save {
        // the compiler knows this branch won't be hit, so coerced the
        // empty match to String
        Save::Error(e) => match e {},
        // ...
    }
}

However, if errors are persisted, you can inspect them

let save: Save<Error>;
match save {
    Save::Error(e) => {
        println!("{}", e);
        if e.is_protocol() { /* .. */ }
    }
    // ...
}

Implementations

impl<'a> Save<'a, Error>

pub fn error(msg: impl Display) -> Self

Convenience method for creating a custom error.

impl<'a, E> Save<'a, E>

pub fn strukt<V>( name: &'a str, fields: impl IntoIterator<Item = (&'a str, V)>, ) -> Self

where V: Into<Save<'a, E>>,

Convenience method for creating a Save::Struct with no skipped fields.

pub fn string(it: impl Into<String>) -> Self

Convenience method for creating a Save::String

pub fn bytes(it: impl Into<Vec<u8>>) -> Self

Convenience method for creating a Save::ByteArray

Trait Implementations

impl<'a, E: Clone> Clone for Save<'a, E>

fn clone(&self) -> Save<'a, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, E: Debug> Debug for Save<'a, E>

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

Formats the value using the given formatter.

impl<'a, 'de> Deserialize<'de> for Save<'a>

This is a best-effort deserialization, provided for completeness.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, E> From<()> for Save<'a, E>

fn from(_: ()) -> Self

Converts to this type from the input type.

impl<'a, E, T0, T1, T2> From<(T0, T1, T2)> for Save<'a, E>

where T0: Into<Save<'a, E>>, T1: Into<Save<'a, E>>, T2: Into<Save<'a, E>>,

You can construct a Save::Tuple using From for tuples of arities between 1 and 24, except 2.

The other implementations are hidden from rustdoc for brevity.

fn from((t0, t1, t2): (T0, T1, T2)) -> Self

Converts to this type from the input type.

impl<'a, E, T> From<Option<T>> for Save<'a, E>

where T: Into<Save<'a, E>>,

fn from(it: Option<T>) -> Self

Converts to this type from the input type.

impl<'a, E> From<String> for Save<'a, E>

fn from(it: String) -> Self

Converts to this type from the input type.

impl<'a, E> From<Variant<'a>> for Save<'a, E>

fn from(it: Variant<'a>) -> Self

Converts to this type from the input type.

impl<'a, E> From<Vec<u8>> for Save<'a, E>

fn from(it: Vec<u8>) -> Self

Converts to this type from the input type.

impl<'a, E> From<bool> for Save<'a, E>

fn from(it: bool) -> Self

Converts to this type from the input type.

impl<'a, E> From<char> for Save<'a, E>

fn from(it: char) -> Self

Converts to this type from the input type.

impl<'a, E> From<f32> for Save<'a, E>

fn from(it: f32) -> Self

Converts to this type from the input type.

impl<'a, E> From<f64> for Save<'a, E>

fn from(it: f64) -> Self

Converts to this type from the input type.

impl<'a, E> From<i128> for Save<'a, E>

fn from(it: i128) -> Self

Converts to this type from the input type.

impl<'a, E> From<i16> for Save<'a, E>

fn from(it: i16) -> Self

Converts to this type from the input type.

impl<'a, E> From<i32> for Save<'a, E>

fn from(it: i32) -> Self

Converts to this type from the input type.

impl<'a, E> From<i64> for Save<'a, E>

fn from(it: i64) -> Self

Converts to this type from the input type.

impl<'a, E> From<i8> for Save<'a, E>

fn from(it: i8) -> Self

Converts to this type from the input type.

impl<'a, E> From<u128> for Save<'a, E>

fn from(it: u128) -> Self

Converts to this type from the input type.

impl<'a, E> From<u16> for Save<'a, E>

fn from(it: u16) -> Self

Converts to this type from the input type.

impl<'a, E> From<u32> for Save<'a, E>

fn from(it: u32) -> Self

Converts to this type from the input type.

impl<'a, E> From<u64> for Save<'a, E>

fn from(it: u64) -> Self

Converts to this type from the input type.

impl<'a, E> From<u8> for Save<'a, E>

fn from(it: u8) -> Self

Converts to this type from the input type.

impl<'a, E, K, V> FromIterator<(K, V)> for Save<'a, E>

where K: Into<Save<'a, E>>, V: Into<Save<'a, E>>,

fn from_iter<II: IntoIterator<Item = (K, V)>>(iter: II) -> Self

Creates a value from an iterator.

impl<'a, E, T> FromIterator<T> for Save<'a, E>

where T: Into<Save<'a, E>>,

fn from_iter<II: IntoIterator<Item = T>>(iter: II) -> Self

Creates a value from an iterator.

impl<'a, E: PartialEq> PartialEq for Save<'a, E>

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

fn partial_cmp(&self, other: &Save<'a, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E> Serialize for Save<'static, E>

where E: Display,

If protocol errors are disabled, this will perfectly preserve the underlying structure of the originally saved item.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, E> StructuralPartialEq for Save<'a, E>