Struct febug::Wrapper

pub struct Wrapper<T: ?Sized> { /* private fields */ }

Create this to register a variable to be debugged

Implementations

impl<T: ?Sized> Wrapper<T>

pub fn new(tp: u64, data: &T, name: Arguments<'_>) -> Wrapper<T>

Call new_signal() with FEBUG_SIGNUM (SIGUSR2 by default)

Examples found in repository

examples/string-sorts.rs (line 36)

fn main() {
    febug::start();
    if febug::install_handler() {
        // Normal registration by TypeId, variables use .wrap(...)
        let mut fmt = febug::FORMATTERS.lock().unwrap();
        fmt.insert(TypeId::of::<String>().into(), |of, vid| {
            let data = unsafe { &*(vid as *const String) };

            let _ = of.write_all(data.as_bytes());
            let _ = of.write_all(b"\n");
        });

        // Custom registration with an explicit type number and Wrapper::new()
        fmt.insert(0.into(), |of: &mut File, _| {
            let _ = write!(of, "{}\n", COMPARISONS.load(Ordering::Relaxed));
        });
    }

    let _comparisons_wrapper = Wrapper::new(0, &COMPARISONS, format_args!("comparisons"));


    let threads = (0..10)
        .map(|i| {
            thread::spawn(move || {
                let mut sorteing = "The quick red fox jumps over the lazy brown \
                                    dog... tHE QUICK RED FOX JUMPS OVER THE \
                                    LAZY BROWN DOG!!"
                                       [0..(i + 1) * 10]
                    .to_string();
                let _sorteing_w = sorteing.wrap(format_args!("cool_data_{}", i));

                unsafe { sorteing.as_bytes_mut() }.sort_unstable_by(|a, b| {
                    thread::sleep(Duration::from_millis(250));
                    COMPARISONS.fetch_add(1, Ordering::Relaxed);
                    a.cmp(b)
                });

                thread::sleep(Duration::from_secs(2));
            })
        })
        .collect::<Vec<_>>();
    for t in threads {
        let _ = t.join();
    }
}

pub fn new_signal( tp: u64, data: &T, signal: u8, name: Arguments<'_> ) -> Wrapper<T>

Register the specified variable of the specified type with the specified name to be notified (if not SIGKILL) on the specified signal to format it

Trait Implementations

impl<T: ?Sized> Drop for Wrapper<T>

fn drop(&mut self)

Deregister the variable