graph-derive 0.0.1

#[derive(Graph)] for graph-theory crate
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

use super::*;

impl ToTokens for EasyTuple {
    fn to_tokens(&self, tokens: &mut TokenStream2) {
        let name = &self.graph_name;
        let ty = &self.field_type;
        let copy = quote! {
            impl Copy for #name {}
            impl Clone for #name {
                #[inline]
                fn clone(&self) -> Self {
                    Self(self.0)
                }
            }
        };
        let eq = quote! {
            impl Eq for #name {}
            impl PartialEq for #name {
                fn eq(&self, other: &Self) -> bool {
                    self.0 == other.0
                }
            }
            impl std::hash::Hash for #name {
                fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
                    self.0.hash(state);
                }
            }
        };
        let ctor = quote! {
            impl #name {
                /// Create a one-way edge.
                #[inline]
                pub const fn one_way(rank: usize) -> Self {
                    Self(rank as #ty)
                }
                /// Create a two-way edge.
                #[inline]
                pub const fn two_way(rank: usize) -> Self {
                    Self(-(rank as #ty))
                }
            }
        };
        let methods = quote! {
            impl #name {
                /// Get the rank of the edge.
                #[inline]
                pub const fn rank(&self) -> usize {
                    self.0.abs() as usize
                }
            }
        };
        let serde = quote! {
            #[cfg(feature = "serde")]
            impl serde::ser::Serialize for #name {
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serializer.serialize_i128(self.0 as i128)
                }
            }

            #[cfg(feature = "serde")]
            impl<'de> serde::de::Deserialize<'de> for #name {
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                where
                    D: serde::de::Deserializer<'de>,
                {
                    i128::deserialize(deserializer).map(|mask| Self(mask as #ty))
                }
            }
        };
        tokens.extend(copy);
        tokens.extend(easy_display(&self.graph_name));
        if self.config.has_wolfram() {
            tokens.extend(easy_wolfram(name, &name.to_string()));
        }
        tokens.extend(eq);
        tokens.extend(serde);
        if self.config.has_constructor() {
            tokens.extend(ctor);
        };
        tokens.extend(methods);
    }
}