use std_::{cmp, fmt};
#[derive(Debug, Copy, Clone, Hash)]
pub enum Void {}
impl Void {
pub fn to<T>(self) -> T {
match self {}
}
}
#[cfg(std)]
impl std_::error::Error for Void {
fn description(&self) -> &str {
match *self {}
}
}
impl fmt::Display for Void {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Eq for Void {}
impl<T: ?Sized> PartialEq<T> for Void {
fn eq(&self, _: &T) -> bool {
self.to()
}
}
impl Ord for Void {
fn cmp(&self, _: &Self) -> cmp::Ordering {
self.to()
}
}
impl<T: ?Sized> PartialOrd<T> for Void {
fn partial_cmp(&self, _: &T) -> Option<cmp::Ordering> {
self.to()
}
}
#[cfg(feature = "serde_")]
pub use self::serde_impl::DeserializeVoidError;
#[cfg(feature = "serde_")]
mod serde_impl {
use super::*;
use serde::de::Error;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Debug, Copy, Clone)]
pub struct DeserializeVoidError;
impl fmt::Display for DeserializeVoidError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(
"Cant deserialize a struct or \
enum variant containing a core_extensions::Void.",
)
}
}
impl<'de> Deserialize<'de> for Void {
fn deserialize<D>(_: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Err(D::Error::custom(DeserializeVoidError))
}
}
impl Serialize for Void {
fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
self.to()
}
}
}