You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
150 lines
3.3 KiB
150 lines
3.3 KiB
use std::{
|
|
mem,
|
|
iter::{
|
|
self,
|
|
ExactSizeIterator,
|
|
FusedIterator,
|
|
},
|
|
slice,
|
|
fmt,
|
|
};
|
|
#[derive(Debug, Clone)]
|
|
pub struct HexStringIter<I>(I, [u8; 2]);
|
|
|
|
/// Represents any value that can be sent and shared across threads
|
|
pub type Dynamic = dyn std::any::Any + Send + Sync + 'static;
|
|
/// Represents any thread-local value
|
|
pub type LocalDynamic = dyn std::any::Any + 'static;
|
|
|
|
impl<I: Iterator<Item = u8>> HexStringIter<I>
|
|
{
|
|
/// Write this hex string iterator to a formattable buffer
|
|
pub fn consume<F>(self, f: &mut F) -> fmt::Result
|
|
where F: std::fmt::Write
|
|
{
|
|
if self.1[0] != 0 {
|
|
write!(f, "{}", self.1[0] as char)?;
|
|
}
|
|
if self.1[1] != 0 {
|
|
write!(f, "{}", self.1[1] as char)?;
|
|
}
|
|
|
|
for x in self.0 {
|
|
write!(f, "{:02x}", x)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Consume into a string
|
|
pub fn into_string(self) -> String
|
|
{
|
|
let mut output = match self.size_hint() {
|
|
(0, None) => String::new(),
|
|
(_, Some(x)) |
|
|
(x, None) => String::with_capacity(x),
|
|
};
|
|
self.consume(&mut output).unwrap();
|
|
output
|
|
}
|
|
}
|
|
|
|
pub trait HexStringIterExt<I>: Sized
|
|
{
|
|
fn into_hex(self) -> HexStringIter<I>;
|
|
}
|
|
|
|
pub type HexStringSliceIter<'a> = HexStringIter<iter::Copied<slice::Iter<'a, u8>>>;
|
|
|
|
pub trait HexStringSliceIterExt
|
|
{
|
|
fn hex(&self) -> HexStringSliceIter<'_>;
|
|
}
|
|
|
|
impl<S> HexStringSliceIterExt for S
|
|
where S: AsRef<[u8]>
|
|
{
|
|
fn hex(&self) -> HexStringSliceIter<'_>
|
|
{
|
|
self.as_ref().iter().copied().into_hex()
|
|
}
|
|
}
|
|
|
|
impl<I: IntoIterator<Item=u8>> HexStringIterExt<I::IntoIter> for I
|
|
{
|
|
#[inline] fn into_hex(self) -> HexStringIter<I::IntoIter> {
|
|
HexStringIter(self.into_iter(), [0u8; 2])
|
|
}
|
|
}
|
|
|
|
impl<I: Iterator<Item = u8>> Iterator for HexStringIter<I>
|
|
{
|
|
type Item = char;
|
|
fn next(&mut self) -> Option<Self::Item>
|
|
{
|
|
match self.1 {
|
|
[_, 0] => {
|
|
use std::io::Write;
|
|
write!(&mut self.1[..], "{:02x}", self.0.next()?).unwrap();
|
|
|
|
Some(mem::replace(&mut self.1[0], 0) as char)
|
|
},
|
|
[0, _] => Some(mem::replace(&mut self.1[1], 0) as char),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
let (l, h) = self.0.size_hint();
|
|
|
|
(l * 2, h.map(|x| x*2))
|
|
}
|
|
}
|
|
|
|
impl<I: Iterator<Item = u8> + ExactSizeIterator> ExactSizeIterator for HexStringIter<I>{}
|
|
impl<I: Iterator<Item = u8> + FusedIterator> FusedIterator for HexStringIter<I>{}
|
|
|
|
impl<I: Iterator<Item = u8>> From<HexStringIter<I>> for String
|
|
{
|
|
fn from(from: HexStringIter<I>) -> Self
|
|
{
|
|
from.into_string()
|
|
}
|
|
}
|
|
|
|
impl<I: Iterator<Item = u8> + Clone> fmt::Display for HexStringIter<I>
|
|
{
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
self.clone().consume(f)
|
|
}
|
|
}
|
|
|
|
#[macro_export] macro_rules! prog1 {
|
|
($first:expr, $($rest:expr);+ $(;)?) => {
|
|
($first, $( $rest ),+).0
|
|
}
|
|
}
|
|
|
|
#[cfg(feature="explicit_clear")]
|
|
#[inline(never)]
|
|
pub fn explicit_prune(buffer : &mut[u8]) {
|
|
use std::ffi::c_void;
|
|
unsafe {
|
|
std::ptr::write_bytes(buffer.as_mut_ptr() as * mut c_void, 0, buffer.len());
|
|
#[cfg(nightly)]
|
|
if cfg!(target_arch = "x86_64") || cfg!(target_arch = "x86") {
|
|
asm!("clflush [{}]", in(reg)buffer.as_mut_ptr());
|
|
} else {
|
|
asm!("")
|
|
}
|
|
#[cfg(not(nightly))] {
|
|
extern "C" {
|
|
fn explicit_bzero(_: *mut c_void, _:usize);
|
|
}
|
|
explicit_bzero(buffer.as_mut_ptr() as *mut c_void, buffer.len());
|
|
|
|
}
|
|
}
|
|
}
|