intuple 0.2.0

Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use intuple::*;

/* -------------------------------------------------------------------------- */
/*                                   Unnamed                                  */
/* -------------------------------------------------------------------------- */

    #[derive(Intuple,Debug,PartialEq)]
    struct Unnamed<T>(u32, u32, T);

    /* ----------------------------------- Std ---------------------------------- */

        #[test]
        fn var_std_unnamed_from_tuple() {
            let a = Unnamed::<u16>::from((3,2,1));
            assert_eq!(a, Unnamed(3,2,1));
        }

        #[test]
        fn var_std_tuple_into_unnamed() {
            let a: Unnamed::<u16> = (3,2,1).into();
            assert_eq!(a, Unnamed::<u16>(3,2,1));
        }

        #[test]
        fn var_std_tuple_from_unnamed() {
            let a = <(u32, u32, u16)>::from(Unnamed::<u16>(3,2,1));
            assert_eq!(a, (3,2,1));
        }

        #[test]
        fn var_std_unnamed_into_tuple() {
            let a: (u32, u32, u16) = Unnamed::<u16>(3,2,1).into();
            assert_eq!(a, (3,2,1));
        }

    /* --------------------------------- Intuple -------------------------------- */

        #[test]
        fn var_itp_unnamed_from_tuple() {
            let a = Unnamed::<u16>::from_tuple((3,2,1));
            assert_eq!(a, Unnamed::<u16>(3,2,1));
        }

        #[test]
        fn var_itp_unnamed_into_tuple() {
            let a: (u32, u32, u16) = Unnamed::<u16>(3,2,1).into_tuple();
            assert_eq!(a, (3,2,1));
            let a: (u32, u32, u16) = Unnamed::<u16>(3,2,1).intuple();
            assert_eq!(a, (3,2,1));
        }

/* -------------------------------------------------------------------------- */
/*                                    Named                                   */
/* -------------------------------------------------------------------------- */

    #[derive(Intuple,Debug,PartialEq)]
    struct Named<T>{a:u32, b:u32, c:T}

    /* ----------------------------------- Std ---------------------------------- */

        #[test]
        fn var_std_named_from_tuple() {
            let a = Named::<u16>::from((3,2,1));
            assert_eq!(a, Named::<u16>{a:3,b:2,c:1});
        }

        #[test]
        fn var_std_tuple_into_named() {
            let a: Named::<u16> = (3,2,1).into();
            assert_eq!(a, Named::<u16>{a:3,b:2,c:1});
        }

        #[test]
        fn var_std_tuple_from_named() {
            let a = <(u32, u32, u16)>::from(Named::<u16>{a:3,b:2,c:1});
            assert_eq!(a, (3,2,1));
        }

        #[test]
        fn var_std_named_into_tuple() {
            let a: (u32, u32, u16) = Named::<u16>{a:3,b:2,c:1}.into();
            assert_eq!(a, (3,2,1));
        }

    /* --------------------------------- Intuple -------------------------------- */

        #[test]
        fn var_itp_named_from_tuple() {
            let a = Named::<u16>::from_tuple((3,2,1));
            assert_eq!(a, Named{a:3,b:2,c:1});
        }

        #[test]
        fn var_itp_named_into_tuple() {
            let a: (u32, u32, u16) = Named::<u16>{a:3,b:2,c:1}.into_tuple();
            assert_eq!(a, (3,2,1));
            let a: (u32, u32, u16) = Named::<u16>{a:3,b:2,c:1}.intuple();
            assert_eq!(a, (3,2,1));
        }

/* ----------------------------------- EOF ---------------------------------- */