chaud 0.1.0

A hot-reloading library for Cargo workspaces designed for ease of use. Unix only.
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

//! Interact with the hot-reloading lifecycle.

#[cfg(feature = "unsafe-hot-reload")]
mod imp {
    pub use chaud_hot::cycle::*;

    pub type Epoch = u32;
}

#[cfg(not(feature = "unsafe-hot-reload"))]
mod imp {
    pub type Epoch = ();

    #[inline]
    pub fn current() {}

    #[inline]
    pub fn check(_: &mut ()) -> bool {
        false
    }

    #[inline]
    #[track_caller]
    pub fn wait(_: &mut ()) {
        panic!("Cannot wait for hot-reload if hot-reloading is disabled.")
    }
}

/// Check for hot reloads since `self` was created.
#[derive(Copy, Clone)]
pub struct Check {
    epoch: imp::Epoch,
}

/// Track hot reloads since the last time any method on `self` was called.
#[derive(Clone)]
pub struct Track {
    epoch: imp::Epoch,
}

impl Check {
    /// Start checking for future hot-reloads.
    #[inline]
    #[must_use]
    #[expect(clippy::new_without_default, reason = "stateful")]
    pub fn new() -> Self {
        Self { epoch: imp::current() }
    }

    /// Returns `true` if a reload has happened (since `self` was created).
    #[inline]
    #[must_use]
    pub fn did_reload(mut self) -> bool {
        imp::check(&mut self.epoch)
    }

    /// Wait for the next reload (since `self` was created).
    ///
    /// Returns immediately such a reload has already occured.
    ///
    /// # Panics
    ///
    /// If hot-reloading is disabled (as this function would block indefinitely
    /// in that case).
    #[inline]
    #[track_caller]
    pub fn wait(mut self) {
        imp::wait(&mut self.epoch);
    }
}

impl Track {
    /// Start tracking future hot-reloads.
    #[inline]
    #[must_use]
    #[expect(clippy::new_without_default, reason = "stateful")]
    pub fn new() -> Self {
        Self { epoch: imp::current() }
    }

    /// Returns `true` if a reload has happened (since `self` was last called).
    #[inline]
    #[must_use]
    pub fn did_reload(&mut self) -> bool {
        imp::check(&mut self.epoch)
    }

    /// Wait for the next reload (since `self` was last called).
    ///
    /// Returns immediately such a reload has already occured.
    ///
    /// # Panics
    ///
    /// If hot-reloading is disabled (as this function would block indefinitely
    /// in that case).
    #[inline]
    #[track_caller]
    pub fn wait(&mut self) {
        imp::wait(&mut self.epoch);
    }
}