Struct As 

pub struct As<T, A> { /* private fields */ }

Holds a value that serializes and deserializes with an adapter.

This implements Serialize and Deserialize with the adapter A. It’s useful to use adapters in places where #[deser(as = ...)] is not available. The wrapper dereferences to the value.

use deser::adapters::{As, DisplayFromStr};

let values: Vec<As<u32, DisplayFromStr>> = vec![As::new(1), As::new(2)];
assert_eq!(*values[0], 1);

Implementations

impl<T, A> As<T, A>

pub fn new(value: T) -> As<T, A>

Wraps a value.

pub fn into_inner(self) -> T

Returns the wrapped value.

Trait Implementations

impl<T: Clone, A> Clone for As<T, A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, A> Copy for As<T, A>

impl<T: Debug, A> Debug for As<T, A>

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

Formats the value using the given formatter.

impl<T: Default, A> Default for As<T, A>

fn default() -> Self

Returns the “default value” for a type.

impl<T, A> Deref for As<T, A>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, A> DerefMut for As<T, A>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<'de, T: Send, A: Deserialize<'de, T>> Deserialize<'de> for As<T, A>

fn deserialize_into<'out>( out: &'out mut Option<Self>, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that deserializes the value into the given slot.

fn expecting() -> Cow<'static, str>

Returns what the value expects, for error messages.

fn initial_value() -> Option<Self>

Provides the value of a missing struct field.

fn describe_type(d: &mut dyn Describe)

Describes the Rust shape of the type.

fn deserialize_atom( slot: &mut Slot<T, Self>, atom: Atom<'_>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom into the slot.

fn deserialize_borrowed_atom( slot: &mut Slot<T, Self>, atom: Atom<'de>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom that borrows from the data being deserialized into the slot.

fn deserialize_update<'out>( value: &'out mut T, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that updates an existing value.

impl<T: Eq, A> Eq for As<T, A>

impl<T, A> From<T> for As<T, A>

fn from(value: T) -> As<T, A>

Converts to this type from the input type.

impl<T: Hash, A> Hash for As<T, A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord, A> Ord for As<T, A>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<T: PartialEq, A> PartialEq for As<T, A>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialOrd, A> PartialOrd for As<T, A>

fn partial_cmp(&self, other: &Self) -> 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<T: Sync, A: Serialize<T>> Serialize for As<T, A>

fn serialize<'a>(value: &'a Self, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn finish(value: &Self, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn is_optional(value: &Self) -> bool

Checks if the value represents an optional value.

fn container_shape(value: &Self) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.

fn describe(value: &Self, d: &mut dyn Describe)

Describes the Rust shape of the value.