Crate benri

Expand description

§`benri`

Convenient macros wrapping the standard library.

This library provides convenient macros around std functionality.

§Modules

Due to how Rust macros are currently exported, all macros will show up in the global namespace: benri::*.

To use specific types of macros, you can import the module instead:

use benri::time::*;

let now = now!();

§Feature flags

log - Enable log usage in certain places

§Example 1 - Flip a bool:

let mut a = false;
flip!(a);
assert!(a == true);
flip!(a);
assert!(a == false);

§Example 2 - Get the current `Instant`:

let now = now!();

std::thread::sleep(std::time::Duration::from_secs(1));

assert!(now.elapsed().as_secs() >= 1);

§Example 3 - Get elapsed `Instant` time:

let now = now!();

std::thread::sleep(std::time::Duration::from_secs(1));
assert!(secs!(now)     >= 1);
assert!(secs_f64!(now) >= 1.0);
assert!(millis!(now)   >= 1000);
assert!(micros!(now)   >= 10000);
assert!(nanos!(now)    >= 100000);

§Example 4 - Sleep a thread:

let now = now!();

// This sleeps the current thread for 1 second.
sleep!(1000);

assert!(secs!(now) >= 1);

§Example 5 - Exit all threads:

std::thread::spawn(|| {
    mass_panic!();
}).join().unwrap();

// The program will has already exited.
// The below statement will never be reached.
unsafe { /* do bad things */ }

§Example 6 - Send/receive a channel message or `mass_panic!()`:

This works with any channel (like crossbeam_channel) that have the same method names as the std channels since the inner macro is calling .send() and .recv().

let (tx, rx) = std::sync::mpsc::channel::<u8>();

std::thread::spawn(move || {
    send!(tx, 255);
}).join().unwrap();

assert!(recv!(rx) == 255);

Modules§

log: Logging functionality using log
mem: std::mem::*
ops: Operators
panic: Panic macros
sync: std::sync::*
thread: std::thread::*
time: std::time::*

Macros§

arc: Calls an Arc::new
arc_mut: Calls Arc::new and Mutex::new
arc_rw: Calls Arc::new and RwLock::new
atomic_add: fetch_add() a std::sync::atomic type with Ordering::SeqCst
atomic_flip: Flip an AtomicBool in place with Ordering::SeqCst.
atomic_load: load a std::sync::atomic type with Ordering::SeqCst
atomic_store: store() a std::sync::atomic type with Ordering::SeqCst
atomic_sub: fetch_sub() a std::sync::atomic type with Ordering::SeqCst
debug_panic: panic!(), but only in debug mode.
drop: Moves all inputs in a scope {} and immediately exits it.
fail: Forward input to log::error!, prefixed with red [FAIL]
flip: Flip a bool in place
forget: Calls std::mem::forget()
half_second: Expands to [std::time::Duration::from_millis(500)]
half_threads: Get 50% the available threads as a usize.
lock: .lock() a Mutex and .unwrap()
lockr: .read() a RwLock and .unwrap()
lockw: .write() to a RwLock and .unwrap()
mass_panic: Terminate all threads.
micros: Calls std::time::Instant::elapsed and std::time::Duration::as_micros()
millis: Calls std::time::Instant::elapsed and std::time::Duration::as_millis()
minute: Expands to [std::time::Duration::from_secs(60)]
most_threads: Gets 80% of the available threads as a usize.
nanos: Calls std::time::Instant::elapsed and std::time::Duration::as_nanos()
now: Expands to std::time::Instant::now()
ok: Forward input to log::info, prefixed with green [ OK ]
ok_debug: Forward input to log::debug, prefixed with green [ OK ]
ok_trace: Forward input to log::trace, prefixed with green [ OK ]
park: Calls std::thread::park
quarter_second: Expands to [std::time::Duration::from_millis(250)]
quarter_threads: Get 25% of the available threads as a usize.
recv: .recv() a channel message and .unwrap()
recv_or_mass: .recv() a channel message, mass_panic! on failure
replace: Calls std::mem::swap(). This automatically appends &mut to dest.
second: Expands to [std::time::Duration::from_secs(1)]
secs: Calls std::time::Instant::elapsed and std::time::Duration::as_secs
secs_f32: Calls std::time::Instant::elapsed and std::time::Duration::as_secs_f32()
secs_f64: Calls std::time::Instant::elapsed and std::time::Duration::as_secs_f64()
send: .send() a channel message and .unwrap()
send_or_mass: .send() a channel message, mass_panic! on failure
size: Calls std::mem::size_of() on the type given
skip: Forward input to log::info, prefixed with white [SKIP]
skip_debug: Forward input to log::debug, prefixed with white [SKIP]
skip_trace: Forward input to log::trace, prefixed with white [SKIP]
skip_warn: Forward input to log::warn, prefixed with white [SKIP]
sleep: Sleep the current thread for x seconds
sleep_micros: Sleep the current thread for x microseconds
sleep_millis: Sleep the current thread for x milliseconds
sleep_nanos: Sleep the current thread for x nanoseconds
swap: Calls std::mem::swap(). This automatically appends &mut to both inputs.
take: Calls std::mem::take(). This automatically appends &mut on the input.
third_second: Expands to [std::time::Duration::from_millis(333)]
threads: Get the total available amount of threads as a usize
unix: Get the seconds elapsed std::time::UNIX_EPOCH
unwrap_or_mass: match a Result, mass_panic! on Result::Err

Crate benriCopy item path

§benri