vbox 0.1.0

type erased Box of trait object
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

use std::fmt::Debug;
use std::marker::PhantomData;
use std::sync::atomic::AtomicU64;
use std::sync::atomic::Ordering;
use std::sync::Arc;

use vbox::from_vbox;
use vbox::into_vbox;
use vbox::VBox;

#[test]
fn test_fn_once() {
    struct NoSend {
        p: PhantomData<*const ()>,
    }

    let n = NoSend {
        p: Default::default(),
    };

    let cnt = Arc::new(AtomicU64::new(0));

    let f = {
        let a = cnt.clone();
        move |_st: &_| {
            a.fetch_add(1, Ordering::Relaxed);
        }
    };

    assert_eq!(0, cnt.load(Ordering::Relaxed));

    let vb: VBox = into_vbox!(dyn FnOnce(&NoSend), f);
    let f2: Box<dyn FnOnce(&NoSend)> = from_vbox!(dyn FnOnce(&NoSend), vb);

    f2(&n);

    assert_eq!(1, cnt.load(Ordering::Relaxed));
}

#[test]
fn test_debug() {
    let v = 3u64;

    let vb: VBox = into_vbox!(dyn Debug, v);
    let p: Box<dyn Debug> = from_vbox!(dyn Debug, vb);

    let got = format!("{:?}", p);
    assert_eq!("3", got);
}

#[test]
fn test_plus() {
    trait Plus {
        fn plus(&self, s: u64) -> u64;
    }

    impl Plus for u64 {
        fn plus(&self, s: u64) -> u64 {
            self + s
        }
    }

    let v = 3u64;

    let vb: VBox = into_vbox!(dyn Plus, v);
    let p: Box<dyn Plus> = from_vbox!(dyn Plus, vb);

    let got = p.plus(1);
    assert_eq!(4, got);
}

#[test]
fn test_drop() {
    trait Plus {
        fn plus(&self, s: u64) -> u64;
    }

    struct Foo {
        a: Arc<AtomicU64>,
    }

    impl Plus for Foo {
        fn plus(&self, s: u64) -> u64 {
            s
        }
    }

    let drop_cnt = Arc::new(AtomicU64::new(0));

    impl Drop for Foo {
        fn drop(&mut self) {
            self.a.fetch_add(1, Ordering::Relaxed);
        }
    }

    let v = Foo {
        a: drop_cnt.clone(),
    };
    assert_eq!(0, drop_cnt.load(Ordering::Relaxed));

    {
        let _vb: VBox = into_vbox!(dyn Plus, v);
    }

    assert_eq!(1, drop_cnt.load(Ordering::Relaxed), "drop is called");

    let v = Foo {
        a: drop_cnt.clone(),
    };
    {
        let vb: VBox = into_vbox!(dyn Plus, v);
        let _p: Box<dyn Plus> = from_vbox!(dyn Plus, vb);
    }
    assert_eq!(2, drop_cnt.load(Ordering::Relaxed), "drop is called");
}