stefans-utils 0.10.1

A collection of useful Rust utility functions, types, and traits.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::sync::Arc;

pub trait AsArc<T> {
    #[allow(clippy::wrong_self_convention)]
    fn as_arc(self) -> Arc<T>;
}

impl<T> AsArc<T> for Arc<T> {
    fn as_arc(self) -> Arc<T> {
        self
    }
}

impl<T> AsArc<T> for &Arc<T> {
    fn as_arc(self) -> Arc<T> {
        self.clone()
    }
}

impl<T> AsArc<T> for T {
    fn as_arc(self) -> Arc<T> {
        Arc::new(self)
    }
}

impl<T: Clone> AsArc<T> for &T {
    fn as_arc(self) -> Arc<T> {
        Arc::new(self.clone())
    }
}

impl<T> AsArc<T> for Box<T> {
    fn as_arc(self) -> Arc<T> {
        Arc::new(*self)
    }
}

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

    #[derive(Debug, PartialEq, Default)]
    struct MyStruct(usize);

    impl Clone for MyStruct {
        fn clone(&self) -> Self {
            Self(self.0 + 1)
        }
    }

    #[test]
    fn as_arc_should_only_clone_a_ref_of_arc() {
        let before = Arc::new(MyStruct::default());

        fn takes_impl(arg: impl AsArc<MyStruct>) -> Arc<MyStruct> {
            arg.as_arc()
        }

        assert_eq!(
            Arc::strong_count(&before),
            1,
            "Arc ref count should be 1 before passing value to takes_impl"
        );
        assert_eq!(
            before.0, 0,
            "Clone count should be 0 before passing value to takes_impl"
        );

        let referenced = takes_impl(&before);

        assert_eq!(
            Arc::strong_count(&referenced),
            2,
            "Arc ref count should be 2 after passing reference to takes_impl"
        );
        assert_eq!(
            Arc::strong_count(&before),
            2,
            "Arc ref count should be 2 after passing reference to takes_impl"
        );
        assert_eq!(
            referenced.0, 0,
            "Clone count should be 0 after passing reference to takes_impl"
        );
        assert_eq!(
            before.0, 0,
            "Clone count should be 0 after passing reference to takes_impl"
        );

        let moved = takes_impl(before);

        assert_eq!(
            Arc::strong_count(&referenced),
            2,
            "Arc ref count should be 2 after moving value to takes_impl"
        );
        assert_eq!(
            Arc::strong_count(&moved),
            2,
            "Arc ref count should be 2 after moving value to takes_impl"
        );
        assert_eq!(
            referenced.0, 0,
            "Clone count should be 0 after moving value to takes_impl"
        );
        assert_eq!(
            moved.0, 0,
            "Clone count should be 0 after moving value to takes_impl"
        );
    }

    #[test]
    fn as_arc_should_only_clone_a_ref_of_inner() {
        let before = MyStruct::default();

        fn takes_impl(arg: impl AsArc<MyStruct>) -> Arc<MyStruct> {
            arg.as_arc()
        }

        assert_eq!(
            before.0, 0,
            "Clone count should be 0 before passing value to takes_impl"
        );

        let arc_from_ref = takes_impl(&before);

        assert_eq!(
            arc_from_ref.0, 1,
            "Inner clone count of arc_from_ref should be 1 after passing reference to takes_impl"
        );
        assert_eq!(
            before.0, 0,
            "Clone count of before should still be 0 after passing reference to takes_impl"
        );

        let arc_from_moved = takes_impl(before);

        assert_eq!(
            arc_from_ref.0, 1,
            "Inner clone count of arc_from_ref should still be 1 after moving original to takes_impl"
        );
        assert_eq!(
            arc_from_moved.0, 0,
            "Inner clone count of arc_from_moved should still be 0 after moving original to takes_impl"
        );
    }
}