path: root/src/iterator/guard.rs

use std::fmt::{Debug, Display};
use std::hash::Hash;
use std::ops::{Deref, DerefMut};

use super::{ConsumedIteratorGuard, IteratorGuard};

#[mutants::skip] // hashing involves RNG and is hard to test
#[cfg(not(tarpaulin_include))]
impl<Guard: Hash, Key> Hash for IteratorGuard<'_, Guard, Key> {
	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
		self.guard.hash(state)
	}
}

// No implementations of Eq, PartialEq, PartialOrd, or Ord
// You can't implement both PartialEq<Self> and PartialEq<T>
// It's easier to just implement neither and ask users to dereference
// This is less of a problem when using the scoped lock API

#[mutants::skip]
#[cfg(not(tarpaulin_include))]
impl<Guard: Debug, Key> Debug for IteratorGuard<'_, Guard, Key> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		Debug::fmt(&**self, f)
	}
}

impl<Guard: Display, Key> Display for IteratorGuard<'_, Guard, Key> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		Display::fmt(&**self, f)
	}
}

impl<Guard, Key> Deref for IteratorGuard<'_, Guard, Key> {
	type Target = Guard;

	fn deref(&self) -> &Self::Target {
		&self.guard
	}
}

impl<Guard, Key> DerefMut for IteratorGuard<'_, Guard, Key> {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.guard
	}
}

impl<Guard, Key> AsRef<Guard> for IteratorGuard<'_, Guard, Key> {
	fn as_ref(&self) -> &Guard {
		&self.guard
	}
}

impl<Guard, Key> AsMut<Guard> for IteratorGuard<'_, Guard, Key> {
	fn as_mut(&mut self) -> &mut Guard {
		&mut self.guard
	}
}