captrack 0.1.0

Capacity telemetry for Rust collections — call-site macros that record peak capacity, with zero overhead when disabled.
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

use std::collections::VecDeque;

use crate::registry;
use crate::IntoInner;

/// A `VecDeque<T>` wrapper that records creation count and peak capacity.
pub struct TrackedVecDeque<T> {
    inner: VecDeque<T>,
    #[allow(dead_code)]
    name: &'static str,
    file: &'static str,
    line: u32,
    column: u32,
}

impl<T> TrackedVecDeque<T> {
    pub fn with_capacity_named(
        cap: usize,
        name: &'static str,
        file: &'static str,
        line: u32,
        column: u32,
    ) -> Self {
        registry::record_creation(name, file, line, column);
        Self {
            inner: VecDeque::with_capacity(cap),
            name,
            file,
            line,
            column,
        }
    }

    /// Wrap an already-constructed `VecDeque<T>` for capacity telemetry.
    ///
    /// Records creation in the registry; `inner` is moved as-is.
    /// Capacity sample recorded at `Drop` as usual.
    #[inline]
    pub fn wrap_from(
        inner: VecDeque<T>,
        name: &'static str,
        file: &'static str,
        line: u32,
        column: u32,
    ) -> Self {
        registry::record_creation(name, file, line, column);
        Self {
            inner,
            name,
            file,
            line,
            column,
        }
    }
}

impl<T> std::ops::Deref for TrackedVecDeque<T> {
    type Target = VecDeque<T>;
    fn deref(&self) -> &VecDeque<T> {
        &self.inner
    }
}

impl<T> std::ops::DerefMut for TrackedVecDeque<T> {
    fn deref_mut(&mut self) -> &mut VecDeque<T> {
        &mut self.inner
    }
}

impl<T> Drop for TrackedVecDeque<T> {
    fn drop(&mut self) {
        registry::record_sample(self.file, self.line, self.column, self.inner.capacity());
    }
}

impl<T> From<TrackedVecDeque<T>> for VecDeque<T> {
    fn from(tracked: TrackedVecDeque<T>) -> VecDeque<T> {
        registry::record_sample(
            tracked.file,
            tracked.line,
            tracked.column,
            tracked.inner.capacity(),
        );
        // SAFETY: `tracked` is owned and forgotten below; ptr::read bit-copies
        // `inner` without requiring Default.
        let inner = unsafe { std::ptr::read(&tracked.inner) };
        std::mem::forget(tracked);
        inner
    }
}

impl<T> IntoInner for TrackedVecDeque<T> {
    type Inner = VecDeque<T>;
    #[inline]
    fn into_inner(self) -> VecDeque<T> {
        VecDeque::from(self)
    }
}

impl<T> IntoIterator for TrackedVecDeque<T> {
    type Item = T;
    type IntoIter = std::collections::vec_deque::IntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        registry::record_sample(self.file, self.line, self.column, self.inner.capacity());
        // SAFETY: `self` is owned and forgotten below; ptr::read bit-copies `inner`.
        let inner = unsafe { std::ptr::read(&self.inner) };
        std::mem::forget(self);
        inner.into_iter()
    }
}