Trait kserd::ToKserd[−][src]

pub trait ToKserd<'a> {
    fn into_kserd(self) -> Result<Kserd<'a>, ToKserdErr>;
}

Convert something into a Kserd.

This differs to encoding in that the object is consumed. This trait allows for less copying as data can be moved, in the case of strings or byte arrays.

Implementing

The crate kserd_derive can be used to annotate objects with #[derive(ToKserd)]. The crate works much in the same way as serde_derive.

If you want to manually implement ToKserd an example is given below.

use kserd::*;
struct MyStruct<'a> {
    e: MyEnum,
    s: &'a str,
    v: Vec<(isize, isize)>,
}

enum MyEnum {
    Variant1,
    Variant2(usize)
}

// let's implement MyEnum first
// it has no references so can be valid for the static lifetime
impl ToKserd<'static> for MyEnum {
    fn into_kserd(self) -> Result<Kserd<'static>, ToKserdErr> {
        let r = match self {
            MyEnum::Variant1 =>
                Kserd::with_id("Variant1", Value::Unit)?,
            // A variant with items is a named Tuple
            MyEnum::Variant2(i) =>
                Kserd::with_id("Variant2", Value::Tuple(vec![
                    i.into_kserd()?
                ]))?,
        };
        Ok(r)
    }
}

// now implement MyStruct
// it has a reference so make it last for that long
impl<'a> ToKserd<'a> for MyStruct<'a> {
    fn into_kserd(self) -> Result<Kserd<'a>, ToKserdErr> {
        Ok(Kserd::with_id("MyStruct", Value::new_cntr(vec![
            ("e", self.e.into_kserd()?),
            ("s", self.s.into_kserd()?),
            ("v", self.v.into_kserd()?),
        ]).unwrap())?) // notice the ? to propogate the error
    }
}

// lets test it
let mys = MyStruct {
    e: MyEnum::Variant2(101),
    s: "Hello, world!",
    v: vec![
        (0, 1),
        (2, 3),
        (4, 5)
    ]
};

let kserd = mys.into_kserd().unwrap();

let s = kserd.as_str();

assert_eq!(
&s,
r#"MyStruct (
    e = Variant2 (101)
    s = "Hello, world!"
    v = [(0, 1), (2, 3), (4, 5)]
)"#
);

Required methods

fn into_kserd(self) -> Result<Kserd<'a>, ToKserdErr>[src]

Consume the object and convert it into a Kserd data object.

Loading content...

Implementations on Foreign Types

impl ToKserd<'static> for usize[src]

impl ToKserd<'static> for u8[src]

impl ToKserd<'static> for u16[src]

impl ToKserd<'static> for u32[src]

impl ToKserd<'static> for u64[src]

impl ToKserd<'static> for u128[src]

impl ToKserd<'static> for isize[src]

impl ToKserd<'static> for i8[src]

impl ToKserd<'static> for i16[src]

impl ToKserd<'static> for i32[src]

impl ToKserd<'static> for i64[src]

impl ToKserd<'static> for i128[src]

impl ToKserd<'static> for f32[src]

impl ToKserd<'static> for f64[src]

impl ToKserd<'static> for ()[src]

impl ToKserd<'static> for bool[src]

impl ToKserd<'static> for char[src]

impl ToKserd<'static> for String[src]

impl<'a> ToKserd<'a> for &'a str[src]

impl<'kserd, 'a: 'kserd, A> ToKserd<'kserd> for (A,) where
    A: ToKserd<'a>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, A, B> ToKserd<'kserd> for (A, B) where
    A: ToKserd<'a>,
    B: ToKserd<'b>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, A, B, C> ToKserd<'kserd> for (A, B, C) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, A, B, C, D> ToKserd<'kserd> for (A, B, C, D) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, A, B, C, D, E> ToKserd<'kserd> for (A, B, C, D, E) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, A, B, C, D, E, F> ToKserd<'kserd> for (A, B, C, D, E, F) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, A, B, C, D, E, F, G> ToKserd<'kserd> for (A, B, C, D, E, F, G) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, 'h: 'kserd, A, B, C, D, E, F, G, H> ToKserd<'kserd> for (A, B, C, D, E, F, G, H) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>,
    H: ToKserd<'h>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, 'h: 'kserd, 'i: 'kserd, A, B, C, D, E, F, G, H, I> ToKserd<'kserd> for (A, B, C, D, E, F, G, H, I) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>,
    H: ToKserd<'h>,
    I: ToKserd<'i>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, 'h: 'kserd, 'i: 'kserd, 'j: 'kserd, A, B, C, D, E, F, G, H, I, J> ToKserd<'kserd> for (A, B, C, D, E, F, G, H, I, J) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>,
    H: ToKserd<'h>,
    I: ToKserd<'i>,
    J: ToKserd<'j>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, 'h: 'kserd, 'i: 'kserd, 'j: 'kserd, 'k: 'kserd, A, B, C, D, E, F, G, H, I, J, K> ToKserd<'kserd> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>,
    H: ToKserd<'h>,
    I: ToKserd<'i>,
    J: ToKserd<'j>,
    K: ToKserd<'k>, [src]

impl<'kserd, 'a: 'kserd, 'b: 'kserd, 'c: 'kserd, 'd: 'kserd, 'e: 'kserd, 'f: 'kserd, 'g: 'kserd, 'h: 'kserd, 'i: 'kserd, 'j: 'kserd, 'k: 'kserd, 'l: 'kserd, A, B, C, D, E, F, G, H, I, J, K, L> ToKserd<'kserd> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: ToKserd<'a>,
    B: ToKserd<'b>,
    C: ToKserd<'c>,
    D: ToKserd<'d>,
    E: ToKserd<'e>,
    F: ToKserd<'f>,
    G: ToKserd<'g>,
    H: ToKserd<'h>,
    I: ToKserd<'i>,
    J: ToKserd<'j>,
    K: ToKserd<'k>,
    L: ToKserd<'l>, [src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 1][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 2][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 3][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 4][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 5][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 6][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 7][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 8][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 9][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 10][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 11][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 12][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 13][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 14][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 15][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 16][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 17][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 18][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 19][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 20][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 21][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 22][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 23][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 24][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 25][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 26][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 27][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 28][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 29][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 30][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 31][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for [T; 32][src]

impl<'a, T: ToKserd<'a>> ToKserd<'a> for Vec<T>[src]

impl<'a, T> ToKserd<'a> for Box<T> where
    T: ToKserd<'a>, [src]

impl<'a, T> ToKserd<'a> for Option<T> where
    T: ToKserd<'a>, [src]

Blanket implementation for Option<T>.

The implementation does not wrap Some values. Rather, if there is something, it is just that value, or it will be an empty tuple with the name None.

let option = Some(String::from("Hello, world!"));
assert_eq!(option.into_kserd(), Ok(Kserd::new_str("Hello, world!")));
let option: Option<String> = None;
assert_eq!(option.into_kserd(), Kserd::with_id("None", Value::Tuple(vec![])).map_err(From::from));

impl<'kserd, 't: 'kserd, 'e: 'kserd, T, E> ToKserd<'kserd> for Result<T, E> where
    T: ToKserd<'t>,
    E: ToKserd<'e>, [src]

Loading content...

Implementors

impl<'a> ToKserd<'a> for Kserd<'a>[src]

Loading content...