Crate benri 

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