#![no_std]
#![cfg_attr(docsrs, feature(doc_cfg))]
extern crate self as numbered;
#[cfg(feature = "alloc")]
extern crate alloc;
#[cfg(feature = "std")]
extern crate std;
#[doc(inline)]
pub use numbered_macros::Numbered;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FromNumberError<T> {
pub number: T,
}
impl<T> FromNumberError<T> {
#[must_use]
pub const fn new(number: T) -> Self {
Self { number }
}
}
impl<T: core::fmt::Display> core::fmt::Display for FromNumberError<T> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "no numbered variant has number {}", self.number)
}
}
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<T: core::fmt::Debug + core::fmt::Display> std::error::Error for FromNumberError<T> {}
#[cfg(feature = "serde")]
#[doc(hidden)]
pub use serde as __serde;
#[cfg(test)]
mod tests {
extern crate std;
use std::string::ToString;
use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Numbered)]
#[numbered(u8)]
enum Kind {
Process,
File,
#[numbered(n = 10)]
Network,
Socket,
}
#[test]
fn numbers_and_tables() {
assert_eq!(Kind::Process.number(), 0u8);
assert_eq!(Kind::File.as_u8(), 1);
assert_eq!(Kind::from_number(10).unwrap(), Kind::Network);
assert_eq!(Kind::try_from(11u8), Ok(Kind::Socket));
assert!(Kind::Process == 0u8);
assert!(0u8 == Kind::Process);
assert_eq!(
Kind::VARIANTS,
&[Kind::Process, Kind::File, Kind::Network, Kind::Socket]
);
assert_eq!(Kind::NUMBERS, &[0, 1, 10, 11]);
assert_eq!(Kind::Process.to_string(), "0");
assert_eq!(u8::from(Kind::File), 1);
assert_eq!(Kind::from_u8(11).unwrap(), Kind::Socket);
}
#[test]
fn parse() {
assert_eq!(Kind::from_u8(10).unwrap(), Kind::Network);
assert!(Kind::from_number(99).is_err());
let err = Kind::from_number(99).unwrap_err();
assert_eq!(err.number, 99);
assert!(err.to_string().contains("99"));
#[cfg(feature = "std")]
{
let _: &dyn std::error::Error = &err;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Numbered)]
#[numbered(i8, start = -1)]
enum Signed {
Neg,
Zero,
Pos = 5,
Next,
}
#[test]
fn signed_start_and_discriminant() {
assert_eq!(Signed::Neg.number(), -1);
assert_eq!(Signed::Zero.as_i8(), 0);
assert_eq!(Signed::Pos.number(), 5);
assert_eq!(Signed::Next.number(), 6);
assert_eq!(Signed::from_number(-1).unwrap(), Signed::Neg);
assert_eq!(Signed::NUMBERS, &[-1, 0, 5, 6]);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Numbered)]
#[numbered(repr = u16, start = 1)]
enum Port {
Http,
Https = 443,
Alt,
}
#[test]
fn repr_key_and_start() {
assert_eq!(Port::Http.as_u16(), 1);
assert_eq!(Port::Https.number(), 443);
assert_eq!(Port::Alt.number(), 444);
assert_eq!(u16::from(Port::Http), 1);
assert_eq!(Port::try_from(443u16), Ok(Port::Https));
}
#[cfg(feature = "serde")]
#[test]
fn serde_roundtrip() {
let v = Kind::Network;
let s = serde_json::to_string(&v).unwrap();
assert_eq!(s, "10");
let back: Kind = serde_json::from_str(&s).unwrap();
assert_eq!(back, v);
assert!(serde_json::from_str::<Kind>("99").is_err());
let process: Kind = serde_json::from_str("0").unwrap();
assert_eq!(process, Kind::Process);
}
}