let parsed: DeriveInput = parse_macro_input!(_item as DeriveInput);

let name = &parsed.ident;

let result = quote! {

impl AsAny for #name {

fn as_any(&self) -> &Any {

self

}

}

};

result.into()

Varint,

Varlong,

String,

U64,

U32,

U16,

U8,

I64,

I32,

I16,

I8,

Position,

Boolean,

F32,

F64,

Uuid,

Nbt,

Slot,

EntityMetadata,

let item: DeriveInput = parse_macro_input!(_item as DeriveInput);

let ident = item.ident.clone();

let fields = match &item.data {

Data::Struct(st) => &st.fields,

_ => panic!("Not a struct"),

};

let mut write_code = vec![];

let mut read_code = vec![];

for field in fields {

let field_name = field.ident.as_ref().unwrap();

let ty = match &field.ty {

Type::Path(path) => &path.path.segments,

_ => panic!("Not a path field"),

};

if ty.len() != 1 {

panic!("Must not use paths");

}

let ty_ident = &ty.first().unwrap().ident;

let parameter_type = PARAMETER_MAPPINGS

.get(ty_ident.to_string().as_str())

.unwrap_or_else(|| {

panic!(

"Couldn't find packet parameter type corresponding to {}",

ty_ident

)

});

let function_ident = Ident::new(

FUNCTION_MAPPINGS.get(parameter_type).unwrap(),

Span::call_site(),

);

let write_fn_ident = Ident::new(&format!("push_{}", function_ident), Span::call_site());

let read_fn_ident = Ident::new(&format!("try_get_{}", function_ident), Span::call_site());

let use_ref = {

vec![

PacketParameterType::Position,

PacketParameterType::String,

PacketParameterType::Uuid,

PacketParameterType::Nbt,

PacketParameterType::EntityMetadata,

]

.contains(parameter_type)

};

let write;

if use_ref {

write = quote! {

buf.#write_fn_ident(&self.#field_name);

};

} else {

write = quote! {

buf.#write_fn_ident(self.#field_name);

}

}

let read;

read = quote! {

self.#field_name = buf.#read_fn_ident()?;

};

write_code.push(write);

read_code.push(read);

}

let r = quote! {

impl Packet for #ident {

fn read_from(&mut self, mut buf: &mut Cursor<&[u8]>) -> anyhow::Result<()> {

#(#read_code)*

Ok(())

}

fn write_to(&self, buf: &mut BytesMut) {

#(#write_code)*

}

fn ty(&self) -> PacketType {

PacketType::#ident

}

fn ty_sized() -> PacketType where Self: Sized {

PacketType::#ident

}

fn box_clone(&self) -> Box<dyn Packet> {

Box::new((*self).clone())

}

}

};

r.into()

let input: syn::DeriveInput = syn::parse(input).unwrap();

let name = &input.ident;

let mut match_arms = vec![];

match &input.data {

syn::Data::Enum(en) => {

for variant in &en.variants {

let snake_case = variant.ident.to_string().to_snake_case();

let ident = &variant.ident;

match_arms.push(quote! {

#snake_case => Some(#name::#ident)

});

}

}

_ => panic!("Can only derive `FromSnakeCase` on enums"),

}

let result = quote! {

impl FromSnakeCase for #name {

fn from_snake_case(val: &str) -> Option<Self> {

match val {

#(#match_arms ,)*

_ => None,

}

}

}

};

result.into()

let input: syn::DeriveInput = syn::parse(input).unwrap();

let name = &input.ident;

let mut match_arms = vec![];

match &input.data {

syn::Data::Enum(en) => {

for variant in &en.variants {

let snake_case = variant.ident.to_string().to_snake_case();

let ident = &variant.ident;

match_arms.push(quote! {

#name::#ident => #snake_case.to_string()

});

}

}

_ => panic!("Can only derive `ToSnakeCase` on enums"),

}

let result = quote! {

impl ToSnakeCase for #name {

fn to_snake_case(&self) -> String {

match self {

#(#match_arms),*

}

}

}

};

result.into()