derive_convert 0.7.0

Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use derive_convert::Convert;

#[derive(Convert)]
#[from(V1 = "Color1")]
enum Color {
    Red,
    #[from(V1(rename("Blues")))]
    Blue,
    #[from(V1(skip))]
    Green,
}

#[allow(dead_code)]
enum Color1 {
    Red,
    Blues,
}

#[derive(Convert)]
#[from_self(COMMON = "Color")]
#[allow(dead_code)]
enum Color2 {
    Red,
    Blue,
    Green,
}

#[derive(Convert)]
#[from(V1("Foo1", ignore("_c")))]
#[from_self(V3("Foo3", default("e")))]
#[allow(dead_code)]
struct Foo {
    a: i32,
    b: String,
    #[from(V1(default))]
    d: f64,
}

struct Foo1 {
    a: i32,
    b: String,
    _c: (),
}

#[derive(Convert)]
#[from_self(COMMON = "Foo")]
struct Foo2 {
    a: i32,
    b: String,
    d: f64,
}

#[allow(dead_code)]
struct Foo3 {
    a: i32,
    b: String,
    d: f64,
    e: Vec<u8>,
}

#[allow(dead_code)]
#[derive(Convert)]
#[from(V1 = "FooColor1")]
enum FooColor {
    Foo(Foo),
    Color(Color),
}

#[allow(dead_code)]
enum FooColor1 {
    Foo(Foo1),
    Color(Color1),
}

#[allow(dead_code)]
#[derive(Convert)]
#[from_self(COMMON = "FooColor")]
enum FooColor2 {
    Foo(Foo2),
    Color(Color2),
}