use std::{ops::Deref, str::FromStr};
use proc_macro2::Ident;
use syn::{parse_str, ItemTrait};
#[derive(Debug)]
pub enum StandardTrait {
AbcTrait,
Any,
Borrow,
BorrowMut,
Eq,
AsMut,
AsRef,
From,
Into,
TryFrom,
TryInto,
Default,
Binary,
Debug,
Display,
LowerExp,
LowerHex,
Octal,
Pointer,
UpperExp,
UpperHex,
Future,
IntoFuture,
FromIterator,
FusedIterator,
IntoIterator,
Product,
Sum,
Copy,
Sized,
ToSocketAddrs,
Add,
AddAssign,
BitAnd,
BitAndAssign,
BitOr,
BitOrAssign,
BitXor,
BitXorAssign,
Deref,
DerefMut,
Div,
DivAssign,
Drop,
Fn,
FnMut,
FnOnce,
Index,
IndexMut,
Mul,
MulAssign,
MultiMethod,
Neg,
Not,
Rem,
RemAssign,
Shl,
ShlAssign,
Shr,
ShrAssign,
Sub,
SubAssign,
Termination,
SliceIndex,
FromStr,
ToString,
}
#[repr(transparent)]
#[derive(Clone, Hash, Debug)]
pub struct TraitSchematic(pub ItemTrait);
impl From<StandardTrait> for TraitSchematic {
fn from(value: StandardTrait) -> Self {
TraitSchematic(
match value {
StandardTrait::AbcTrait => parse_str(include_str!("./AbcTrait.rs")),
StandardTrait::Any => parse_str(include_str!("./Any.rs")),
StandardTrait::Borrow => parse_str(include_str!("./Borrow.rs")),
StandardTrait::BorrowMut => parse_str(include_str!("./BorrowMut.rs")),
StandardTrait::Eq => parse_str(include_str!("./Eq.rs")),
StandardTrait::AsMut => parse_str(include_str!("./AsMut.rs")),
StandardTrait::AsRef => parse_str(include_str!("./AsRef.rs")),
StandardTrait::From => parse_str(include_str!("./From.rs")),
StandardTrait::Into => parse_str(include_str!("./Into.rs")),
StandardTrait::TryFrom => parse_str(include_str!("./TryFrom.rs")),
StandardTrait::TryInto => parse_str(include_str!("./TryInto.rs")),
StandardTrait::Default => parse_str(include_str!("./Default.rs")),
StandardTrait::Binary => parse_str(include_str!("./Binary.rs")),
StandardTrait::Debug => parse_str(include_str!("./Debug.rs")),
StandardTrait::Display => parse_str(include_str!("./Display.rs")),
StandardTrait::LowerExp => parse_str(include_str!("./LowerExp.rs")),
StandardTrait::LowerHex => parse_str(include_str!("./LowerHex.rs")),
StandardTrait::Octal => parse_str(include_str!("./Octal.rs")),
StandardTrait::Pointer => parse_str(include_str!("./Pointer.rs")),
StandardTrait::UpperExp => parse_str(include_str!("./UpperExp.rs")),
StandardTrait::UpperHex => parse_str(include_str!("./UpperHex.rs")),
StandardTrait::Future => parse_str(include_str!("./Future.rs")),
StandardTrait::IntoFuture => parse_str(include_str!("./IntoFuture.rs")),
StandardTrait::FromIterator => parse_str(include_str!("./FromIterator.rs")),
StandardTrait::FusedIterator => parse_str(include_str!("./FusedIterator.rs")),
StandardTrait::IntoIterator => parse_str(include_str!("./IntoIterator.rs")),
StandardTrait::Product => parse_str(include_str!("./Product.rs")),
StandardTrait::Sum => parse_str(include_str!("./Sum.rs")),
StandardTrait::Copy => parse_str(include_str!("./Copy.rs")),
StandardTrait::Sized => parse_str(include_str!("./Sized.rs")),
StandardTrait::ToSocketAddrs => parse_str(include_str!("./ToSocketAddrs.rs")),
StandardTrait::Add => parse_str(include_str!("./Add.rs")),
StandardTrait::AddAssign => parse_str(include_str!("./AddAssign.rs")),
StandardTrait::BitAnd => parse_str(include_str!("./BitAnd.rs")),
StandardTrait::BitAndAssign => parse_str(include_str!("./BitAndAssign.rs")),
StandardTrait::BitOr => parse_str(include_str!("./BitOr.rs")),
StandardTrait::BitOrAssign => parse_str(include_str!("./BitOrAssign.rs")),
StandardTrait::BitXor => parse_str(include_str!("./BitXor.rs")),
StandardTrait::BitXorAssign => parse_str(include_str!("./BitXorAssign.rs")),
StandardTrait::Deref => parse_str(include_str!("./Deref.rs")),
StandardTrait::DerefMut => parse_str(include_str!("./DerefMut.rs")),
StandardTrait::Div => parse_str(include_str!("./Div.rs")),
StandardTrait::DivAssign => parse_str(include_str!("./DivAssign.rs")),
StandardTrait::Drop => parse_str(include_str!("./Drop.rs")),
StandardTrait::Fn => parse_str(include_str!("./Fn.rs")),
StandardTrait::FnMut => parse_str(include_str!("./FnMut.rs")),
StandardTrait::FnOnce => parse_str(include_str!("./FnOnce.rs")),
StandardTrait::Index => parse_str(include_str!("./Index.rs")),
StandardTrait::IndexMut => parse_str(include_str!("./IndexMut.rs")),
StandardTrait::Mul => parse_str(include_str!("./Mul.rs")),
StandardTrait::MulAssign => parse_str(include_str!("./MulAssign.rs")),
StandardTrait::MultiMethod => parse_str(include_str!("./MultiMethod.rs")),
StandardTrait::Neg => parse_str(include_str!("./Neg.rs")),
StandardTrait::Not => parse_str(include_str!("./Not.rs")),
StandardTrait::Rem => parse_str(include_str!("./Rem.rs")),
StandardTrait::RemAssign => parse_str(include_str!("./RemAssign.rs")),
StandardTrait::Shl => parse_str(include_str!("./Shl.rs")),
StandardTrait::ShlAssign => parse_str(include_str!("./ShlAssign.rs")),
StandardTrait::Shr => parse_str(include_str!("./Shr.rs")),
StandardTrait::ShrAssign => parse_str(include_str!("./ShrAssign.rs")),
StandardTrait::Sub => parse_str(include_str!("./Sub.rs")),
StandardTrait::SubAssign => parse_str(include_str!("./SubAssign.rs")),
StandardTrait::Termination => parse_str(include_str!("./Termination.rs")),
StandardTrait::SliceIndex => parse_str(include_str!("./SliceIndex.rs")),
StandardTrait::FromStr => parse_str(include_str!("./FromStr.rs")),
StandardTrait::ToString => parse_str(include_str!("./ToString.rs")),
}
.expect("Std trait file should exist"),
)
}
}
impl FromStr for StandardTrait {
type Err = ();
fn from_str(value: &str) -> Result<Self, ()> {
match value {
"AbcTrait" => Ok(Self::AbcTrait),
"Any" => Ok(Self::Any),
"Borrow" => Ok(Self::Borrow),
"BorrowMut" => Ok(Self::BorrowMut),
"Eq" => Ok(Self::Eq),
"AsMut" => Ok(Self::AsMut),
"AsRef" => Ok(Self::AsRef),
"From" => Ok(Self::From),
"Into" => Ok(Self::Into),
"TryFrom" => Ok(Self::TryFrom),
"TryInto" => Ok(Self::TryInto),
"Default" => Ok(Self::Default),
"Binary" => Ok(Self::Binary),
"Debug" => Ok(Self::Debug),
"Display" => Ok(Self::Display),
"LowerExp" => Ok(Self::LowerExp),
"LowerHex" => Ok(Self::LowerHex),
"Octal" => Ok(Self::Octal),
"Pointer" => Ok(Self::Pointer),
"UpperExp" => Ok(Self::UpperExp),
"UpperHex" => Ok(Self::UpperHex),
"Future" => Ok(Self::Future),
"IntoFuture" => Ok(Self::IntoFuture),
"FromIterator" => Ok(Self::FromIterator),
"FusedIterator" => Ok(Self::FusedIterator),
"IntoIterator" => Ok(Self::IntoIterator),
"Product" => Ok(Self::Product),
"Sum" => Ok(Self::Sum),
"Copy" => Ok(Self::Copy),
"Sized" => Ok(Self::Sized),
"ToSocketAddrs" => Ok(Self::ToSocketAddrs),
"Add" => Ok(Self::Add),
"AddAssign" => Ok(Self::AddAssign),
"BitAnd" => Ok(Self::BitAnd),
"BitAndAssign" => Ok(Self::BitAndAssign),
"BitOr" => Ok(Self::BitOr),
"BitOrAssign" => Ok(Self::BitOrAssign),
"BitXor" => Ok(Self::BitXor),
"BitXorAssign" => Ok(Self::BitXorAssign),
"Deref" => Ok(Self::Deref),
"DerefMut" => Ok(Self::DerefMut),
"Div" => Ok(Self::Div),
"DivAssign" => Ok(Self::DivAssign),
"Drop" => Ok(Self::Drop),
"Fn" => Ok(Self::Fn),
"FnMut" => Ok(Self::FnMut),
"FnOnce" => Ok(Self::FnOnce),
"Index" => Ok(Self::Index),
"IndexMut" => Ok(Self::IndexMut),
"Mul" => Ok(Self::Mul),
"MulAssign" => Ok(Self::MulAssign),
"MultiMethod" => Ok(Self::MultiMethod),
"Neg" => Ok(Self::Neg),
"Not" => Ok(Self::Not),
"Rem" => Ok(Self::Rem),
"RemAssign" => Ok(Self::RemAssign),
"Shl" => Ok(Self::Shl),
"ShlAssign" => Ok(Self::ShlAssign),
"Shr" => Ok(Self::Shr),
"ShrAssign" => Ok(Self::ShrAssign),
"Sub" => Ok(Self::Sub),
"SubAssign" => Ok(Self::SubAssign),
"Termination" => Ok(Self::Termination),
"SliceIndex" => Ok(Self::SliceIndex),
"FromStr" => Ok(Self::FromStr),
"ToString" => Ok(Self::ToString),
_ => Err(()),
}
}
}
impl TryFrom<&Ident> for StandardTrait {
type Error = ();
fn try_from(value: &Ident) -> Result<Self, Self::Error> {
StandardTrait::from_str(value.to_string().as_str())
}
}
impl Deref for TraitSchematic {
type Target = ItemTrait;
fn deref(&self) -> &Self::Target {
&self.0
}
}