Trait nanoserde::DeRon

pub trait DeRon: Sized {
    fn de_ron(
        state: &mut DeRonState, 
        input: &mut Chars<'_>
    ) -> Result<Self, DeRonErr>;

    fn deserialize_ron(input: &str) -> Result<Self, DeRonErr> { ... }
}

A trait for objects that can be deserialized from the RON file format.

Specification.

Required methods

fn de_ron(
    state: &mut DeRonState,
    input: &mut Chars<'_>
) -> Result<Self, DeRonErr>

Parse Self from a RON string.

let mut state = DeRonState::default();
let mut chars = "42".chars();
state.next(&mut chars);
state.next_tok(&mut chars).unwrap();
let out = u32::de_ron(&mut state, &mut chars).unwrap();
assert_eq!(out, 42);

Loading content...

Provided methods

fn deserialize_ron(input: &str) -> Result<Self, DeRonErr>

Parse Self from a RON string.

This is a convenient wrapper around de_ron.

Loading content...

Implementations on Foreign Types

impl DeRon for usize

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<usize, DeRonErr>

impl DeRon for u64

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<u64, DeRonErr>

impl DeRon for u32

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<u32, DeRonErr>

impl DeRon for u16

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<u16, DeRonErr>

impl DeRon for u8

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<u8, DeRonErr>

impl DeRon for i64

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<i64, DeRonErr>

impl DeRon for i32

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<i32, DeRonErr>

impl DeRon for i16

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<i16, DeRonErr>

impl DeRon for i8

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<i8, DeRonErr>

impl DeRon for f64

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<f64, DeRonErr>

impl DeRon for f32

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<f32, DeRonErr>

impl<T> DeRon for Option<T> where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl DeRon for bool

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<bool, DeRonErr>

impl DeRon for String

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<String, DeRonErr>

impl<T> DeRon for Vec<T> where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Vec<T>, DeRonErr>

impl<T> DeRon for [T; 2] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 3] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 4] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 5] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 6] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 7] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 8] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 9] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 10] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 11] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 12] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 13] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 14] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 15] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 16] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 17] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 18] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 19] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 20] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 21] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 22] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 23] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 24] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 25] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 26] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 27] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 28] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 29] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 30] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 31] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for [T; 32] where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<A, B> DeRon for (A, B) where
    A: DeRon,
    B: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<(A, B), DeRonErr>

impl<A, B, C> DeRon for (A, B, C) where
    A: DeRon,
    B: DeRon,
    C: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<(A, B, C), DeRonErr>

impl<A, B, C, D> DeRon for (A, B, C, D) where
    A: DeRon,
    B: DeRon,
    C: DeRon,
    D: DeRon, 

fn de_ron(
    s: &mut DeRonState,
    i: &mut Chars<'_>
) -> Result<(A, B, C, D), DeRonErr>

impl<K, V> DeRon for HashMap<K, V> where
    K: DeRon + Eq + Hash,
    V: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Self, DeRonErr>

impl<T> DeRon for Box<T> where
    T: DeRon, 

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Box<T>, DeRonErr>

Loading content...

Implementors

Loading content...