mod owningorref {
use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
use std::{
fmt::{self, Debug}, ops::Deref
};
pub enum OwningOrRef<'a, T>
where
T: Deref,
{
Owning(T),
Ref(&'a T::Target),
}
impl<'a, T> OwningOrRef<'a, T>
where
T: Deref,
{
pub fn into_inner(self) -> Option<T> {
match self {
Self::Owning(a) => Some(a),
Self::Ref(_) => None,
}
}
}
impl<'a, T> Clone for OwningOrRef<'a, T>
where
T: Deref + Clone,
{
fn clone(&self) -> Self {
match self {
Self::Owning(a) => Self::Owning(a.clone()),
Self::Ref(a) => Self::Ref(Clone::clone(a)),
}
}
}
impl<'a, T> Copy for OwningOrRef<'a, T> where T: Deref + Copy {}
impl<'a, T> Debug for OwningOrRef<'a, T>
where
T: Deref + Debug,
T::Target: Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Owning(a) => a.fmt(f),
Self::Ref(a) => a.fmt(f),
}
}
}
impl<'a, T> Deref for OwningOrRef<'a, T>
where
T: Deref,
{
type Target = T::Target;
fn deref(&self) -> &Self::Target {
match self {
Self::Owning(a) => &**a,
Self::Ref(a) => a,
}
}
}
impl<'a, T> Serialize for OwningOrRef<'a, T>
where
T: Deref,
T::Target: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
(**self).serialize(serializer)
}
}
impl<'de, 'a, T> Deserialize<'de> for OwningOrRef<'a, T>
where
T: Deref + Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
T::deserialize(deserializer).map(Self::Owning)
}
}
}
pub use self::owningorref::OwningOrRef;
mod bufferedstream {
use std::io::{self, Read, Write};
#[derive(Debug)]
pub struct BufferedStream<T: Read + Write> {
stream: io::BufReader<T>,
}
impl<T: Read + Write> BufferedStream<T> {
pub fn new(stream: T) -> Self {
Self {
stream: io::BufReader::new(stream),
}
}
pub fn write(&mut self) -> BufferedStreamWriter<T> {
BufferedStreamWriter(io::BufWriter::new(self))
}
pub fn get_ref(&self) -> &T {
self.stream.get_ref()
}
pub fn get_mut(&mut self) -> &mut T {
self.stream.get_mut()
}
}
impl<T: Read + Write> Read for BufferedStream<T> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.stream.read(buf)
}
}
impl<'a, T: Read + Write + 'a> Write for &'a mut BufferedStream<T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.stream.get_mut().write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.stream.get_mut().flush()
}
}
#[derive(Debug)]
pub struct BufferedStreamWriter<'a, T: Read + Write + 'a>(
io::BufWriter<&'a mut BufferedStream<T>>,
);
impl<'a, T: Read + Write + 'a> Write for BufferedStreamWriter<'a, T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.0.flush()
}
}
impl<'a, T: Read + Write + 'a> Drop for BufferedStreamWriter<'a, T> {
fn drop(&mut self) {
self.0.flush().unwrap();
}
}
}
pub use self::bufferedstream::BufferedStream;
mod to_hex {
use std::fmt;
#[derive(Clone, Debug)]
pub struct Hex<'a>(&'a [u8], bool);
impl<'a> Iterator for Hex<'a> {
type Item = char;
fn next(&mut self) -> Option<char> {
if !self.0.is_empty() {
const CHARS: &[u8] = b"0123456789abcdef";
let byte = self.0[0];
let second = self.1;
if second {
self.0 = self.0.split_first().unwrap().1;
}
self.1 = !self.1;
Some(CHARS[if !second { byte >> 4 } else { byte & 0xf } as usize] as char)
} else {
None
}
}
}
impl<'a> fmt::Display for Hex<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for char_ in self.clone() {
write!(f, "{}", char_)?;
}
Ok(())
}
}
pub trait ToHex {
fn to_hex(&self) -> Hex;
}
impl ToHex for [u8] {
fn to_hex(&self) -> Hex {
Hex(&*self, false)
}
}
}
pub use self::to_hex::ToHex;
mod rand_stream {
#[derive(Debug)]
pub struct Rand<T> {
res: Option<T>,
count: usize,
}
impl<T> Rand<T> {
pub fn new() -> Self {
Self {
res: None,
count: 0,
}
}
pub fn push<R: rand::Rng>(&mut self, x: T, rng: &mut R) {
self.count += 1;
if rng.gen_range(0, self.count) == 0 {
self.res = Some(x);
}
}
pub fn get(self) -> Option<T> {
self.res
}
}
impl<T> Default for Rand<T> {
fn default() -> Self {
Self::new()
}
}
}
pub use self::rand_stream::Rand;