yowl 0.1.0

Primitives for reading and writing the SMILES language
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::feature::BondKind;

pub fn reconcile(left: BondKind, right: &BondKind) -> Option<(BondKind, BondKind)> {
    use BondKind::{Down, Elided, Up};
    match (&left, &right) {
        (Up, Up) | (Down, Down) => None,
        (Up, Down) | (Down, Up) => Some((left, *right)),
        (Elided, Elided) => Some((Elided, Elided)),
        (Elided, Up) | (Down, Elided) => Some((Down, Up)),
        (Elided, Down) | (Up, Elided) => Some((Up, Down)),
        (other, Elided) | (Elided, &other) => Some((*other, *other)),
        (a, b) if a == *b => Some((*a, **b)),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn single_double() {
        assert_eq!(reconcile(BondKind::Single, &BondKind::Double), None)
    }

    #[test]
    fn up_up() {
        assert_eq!(reconcile(BondKind::Up, &BondKind::Up), None)
    }

    #[test]
    fn down_down() {
        assert_eq!(reconcile(BondKind::Down, &BondKind::Down), None)
    }

    #[test]
    fn elided_elided() {
        assert_eq!(
            reconcile(BondKind::Elided, &BondKind::Elided),
            Some((BondKind::Elided, BondKind::Elided))
        )
    }

    #[test]
    fn elided_single() {
        assert_eq!(
            reconcile(BondKind::Elided, &BondKind::Single),
            Some((BondKind::Single, BondKind::Single))
        )
    }

    #[test]
    fn elided_up() {
        assert_eq!(
            reconcile(BondKind::Elided, &BondKind::Up),
            Some((BondKind::Down, BondKind::Up))
        )
    }

    #[test]
    fn elided_down() {
        assert_eq!(
            reconcile(BondKind::Elided, &BondKind::Down),
            Some((BondKind::Up, BondKind::Down))
        )
    }

    #[test]
    fn up_elided() {
        assert_eq!(
            reconcile(BondKind::Up, &BondKind::Elided),
            Some((BondKind::Up, BondKind::Down))
        )
    }

    #[test]
    fn down_elided() {
        assert_eq!(
            reconcile(BondKind::Down, &BondKind::Elided),
            Some((BondKind::Down, BondKind::Up))
        )
    }

    #[test]
    fn up_down() {
        assert_eq!(
            reconcile(BondKind::Up, &BondKind::Down),
            Some((BondKind::Up, BondKind::Down))
        )
    }

    #[test]
    fn down_up() {
        assert_eq!(
            reconcile(BondKind::Down, &BondKind::Up),
            Some((BondKind::Down, BondKind::Up))
        )
    }

    #[test]
    fn single_elided() {
        assert_eq!(
            reconcile(BondKind::Single, &BondKind::Elided),
            Some((BondKind::Single, BondKind::Single))
        )
    }

    #[test]
    fn other_bonds() {
        assert_eq!(
            reconcile(BondKind::Triple, &BondKind::Triple),
            Some((BondKind::Triple, BondKind::Triple))
        )
    }
}