nsys-rs-utils 0.3.0

Miscellaneous Rust utilities
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

//! Utility macros

/// Expands into a series of for loops with the given block of code which should
/// treat each type uniformly.
///
/// This is to avoid dynamic dispatch when chaining iterators over generic
/// collections when the types are known.
pub macro for_sequence {
  ( $pattern:pat in ($($iter:expr),+) $do:block) => {
    $(for $pattern in $iter $do)+
  }
}

/// Print the stringified expression followed by its debug formatting
pub macro show {
  ($e:expr) => {
    println!("{}: {:?}", stringify!($e), $e);
  }
}

/// Print the stringified expression to stderr followed by its debug formatting
pub macro eshow {
  ($e:expr) => {
    eprintln!("{}: {:?}", stringify!($e), $e);
  }
}

/// Print the stringified expression followed by its pretty debug formatting
pub macro pretty {
  ($e:expr) => {
    println!("{}: {:#?}", stringify!($e), $e);
  }
}

/// Print the stringified expression to stderr followed by its pretty debug formatting
pub macro epretty {
  ($e:expr) => {
    eprintln!("{}: {:#?}", stringify!($e), $e);
  }
}

/// Print the stringified expression followed by its display formatting
pub macro display {
  ($e:expr) => {
    println!("{}: {}", stringify!($e), $e);
  }
}

/// Print the stringified expression to stderr followed by its display formatting
pub macro edisplay {
  ($e:expr) => {
    eprintln!("{}: {}", stringify!($e), $e);
  }
}

/// Print the stringified expression followed by its bitstring formatting
pub macro bits {
  ($e:expr) => {
    let e = $e;
    println!("{}: {:02$b}", stringify!($e), e, 8 * core::mem::size_of_val (&e));
  }
}

/// Print the stringified expression to stderr followed by its bitstring formatting
pub macro ebits {
  ($e:expr) => {
    let e = $e;
    eprintln!("{}: {:02$b}", stringify!($e), e, 8 * core::mem::size_of_val (&e));
  }
}

/// Print the stringified expression followed by its hexadecimal formatting
pub macro hex {
  ($e:expr) => {
    println!("{}: {:x}", stringify!($e), $e);
  }
}

/// Print the stringified expression to stderr followed by its hexadecimal formatting
pub macro ehex {
  ($e:expr) => {
    println!("{}: {:x}", stringify!($e), $e);
  }
}

/// Print the stringified expression followed by its pointer formatting
pub macro address {
  ($e:expr) => {
    println!("{}: {:p}", stringify!($e), $e);
  }
}

/// Print the stringified expression to stderr followed by its pointer formatting
pub macro eaddress {
  ($e:expr) => {
    eprintln!("{}: {:p}", stringify!($e), $e);
  }
}