Struct serde_with::As

pub struct As<T: ?Sized>(_);

Adapter to convert from serde_as to the serde traits.

The As type adapter allows using types which implement DeserializeAs or SerializeAs in place of serde’s with-annotation. The with-annotation allows running custom code when de/serializing, however it is quite inflexible. The traits DeserializeAs/SerializeAs are more flexible, as they allow composition and nesting of types to create more complex de/serialization behavior. However, they are not directly compatible with serde, as they are not provided by serde. The As type adapter makes them compatible, by forwarding the function calls to serialize/deserialize to the corresponding functions serialize_as and deserialize_as.

It is not required to use this type directly. Instead, it is highly encouraged to use the #[serde_as] attribute since it includes further usability improvements. If the use of the use of the proc-macro is not acceptable, then As can be used directly with serde.

#[derive(Deserialize, Serialize)]
// Serialize numbers as sequence of strings, using Display and FromStr
#[serde(with = "As::<Vec<DisplayFromStr>>")]
field: Vec<u8>,

If the normal Deserialize/Serialize traits should be used, the placeholder type Same can be used. It implements DeserializeAs/SerializeAs, when the underlying type implements Deserialize/Serialize.

#[derive(Deserialize, Serialize)]
// Serialize map, turn keys into strings but keep type of value
#[serde(with = "As::<BTreeMap<DisplayFromStr, Same>>")]
field: BTreeMap<u8, i32>,

Implementations

impl<T: ?Sized> As<T>

pub fn serialize<S, I>(value: &I, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer,
    T: SerializeAs<I>,
    I: ?Sized, 

Serialize type T using SerializeAs

The function signature is compatible with serde’s with-annotation.

pub fn deserialize<'de, D, I>(deserializer: D) -> Result<I, D::Error> where
    T: DeserializeAs<'de, I>,
    D: Deserializer<'de>, 

Deserialize type T using DeserializeAs

The function signature is compatible with serde’s with-annotation.

Trait Implementations

impl<T: Clone + ?Sized> Clone for As<T>

fn clone(&self) -> As<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for As<T>

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

Formats the value using the given formatter.

impl<T: Default + ?Sized> Default for As<T>

fn default() -> As<T>

Returns the “default value” for a type.

impl<T: Copy + ?Sized> Copy for As<T>