summaryrefslogtreecommitdiffstats
path: root/third_party/rust/enum-primitive-derive/src/lib.rs
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/enum-primitive-derive/src/lib.rs')
-rw-r--r--third_party/rust/enum-primitive-derive/src/lib.rs278
1 files changed, 278 insertions, 0 deletions
diff --git a/third_party/rust/enum-primitive-derive/src/lib.rs b/third_party/rust/enum-primitive-derive/src/lib.rs
new file mode 100644
index 0000000000..135f6164c7
--- /dev/null
+++ b/third_party/rust/enum-primitive-derive/src/lib.rs
@@ -0,0 +1,278 @@
+// Copyright (c) 2017 Doug Goldstein <cardoe@cardoe.com>
+
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// “Software”), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+//! This crate provides a custom derive `Primitive` that helps people
+//! providing native Rust bindings to C code by allowing a C-like `enum`
+//! declaration to convert to its primitve values and back from them. You
+//! can selectively include `num_traits::ToPrimitive` and
+//! `num_traits::FromPrimitive` to get these features.
+//!
+//! # Example
+//!
+//! ```rust
+//! use enum_primitive_derive::Primitive;
+//! use num_traits::{FromPrimitive, ToPrimitive};
+//!
+//! #[derive(Debug, Eq, PartialEq, Primitive)]
+//! enum Foo {
+//! Bar = 32,
+//! Dead = 42,
+//! Beef = 50,
+//! }
+//!
+//! fn main() {
+//! assert_eq!(Foo::from_i32(32), Some(Foo::Bar));
+//! assert_eq!(Foo::from_i32(42), Some(Foo::Dead));
+//! assert_eq!(Foo::from_i64(50), Some(Foo::Beef));
+//! assert_eq!(Foo::from_isize(17), None);
+//!
+//! let bar = Foo::Bar;
+//! assert_eq!(bar.to_i32(), Some(32));
+//!
+//! let dead = Foo::Dead;
+//! assert_eq!(dead.to_isize(), Some(42));
+//! }
+//! ```
+//!
+//! # Complex Example
+//!
+//! ```rust
+//! use enum_primitive_derive::Primitive;
+//! use num_traits::{FromPrimitive, ToPrimitive};
+//!
+//! pub const ABC: ::std::os::raw::c_uint = 1;
+//! pub const DEF: ::std::os::raw::c_uint = 2;
+//! pub const GHI: ::std::os::raw::c_uint = 4;
+//!
+//! #[derive(Clone, Copy, Debug, Eq, PartialEq, Primitive)]
+//! enum BindGenLike {
+//! ABC = ABC as isize,
+//! DEF = DEF as isize,
+//! GHI = GHI as isize,
+//! }
+//!
+//! fn main() {
+//! assert_eq!(BindGenLike::from_isize(4), Some(BindGenLike::GHI));
+//! assert_eq!(BindGenLike::from_u32(2), Some(BindGenLike::DEF));
+//! assert_eq!(BindGenLike::from_u32(8), None);
+//!
+//! let abc = BindGenLike::ABC;
+//! assert_eq!(abc.to_u32(), Some(1));
+//! }
+//! ```
+//!
+//! # TryFrom Example
+//!
+//! ```rust
+//! use enum_primitive_derive::Primitive;
+//! use core::convert::TryFrom;
+//!
+//! #[derive(Debug, Eq, PartialEq, Primitive)]
+//! enum Foo {
+//! Bar = 32,
+//! Dead = 42,
+//! Beef = 50,
+//! }
+//!
+//! fn main() {
+//! let bar = Foo::try_from(32);
+//! assert_eq!(bar, Ok(Foo::Bar));
+//!
+//! let dead = Foo::try_from(42);
+//! assert_eq!(dead, Ok(Foo::Dead));
+//!
+//! let unknown = Foo::try_from(12);
+//! assert!(unknown.is_err());
+//! }
+//! ```
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+/// Provides implementation of `num_traits::ToPrimitive` and
+/// `num_traits::FromPrimitive`
+#[proc_macro_derive(Primitive)]
+pub fn primitive(input: TokenStream) -> TokenStream {
+ let ast = syn::parse_macro_input!(input as syn::DeriveInput);
+ impl_primitive(&ast)
+}
+
+fn impl_primitive(ast: &syn::DeriveInput) -> TokenStream {
+ let name = &ast.ident;
+
+ // Check if derive(Primitive) was specified for a struct
+ if let syn::Data::Enum(ref variant) = ast.data {
+ let (var_u64, dis_u64): (Vec<_>, Vec<_>) = variant
+ .variants
+ .iter()
+ .map(|v| {
+ match v.fields {
+ syn::Fields::Unit => (),
+ _ => panic!("#[derive(Primitive) can only operate on C-like enums"),
+ }
+ if v.discriminant.is_none() {
+ panic!(
+ "#[derive(Primitive) requires C-like enums with \
+ discriminants for all enum variants"
+ );
+ }
+
+ let discrim = match v.discriminant.clone().map(|(_eq, expr)| expr).unwrap() {
+ syn::Expr::Cast(real) => *real.expr,
+ orig => orig,
+ };
+ (v.ident.clone(), discrim)
+ })
+ .unzip();
+
+ // quote!{} needs this to be a vec since its in #( )*
+ let enum_u64 = vec![name.clone(); variant.variants.len()];
+
+ // can't reuse variables in quote!{} body
+ let var_i64 = var_u64.clone();
+ let dis_i64 = dis_u64.clone();
+ let enum_i64 = enum_u64.clone();
+
+ let to_name = name.clone();
+ let to_enum_u64 = enum_u64.clone();
+ let to_var_u64 = var_u64.clone();
+ let to_dis_u64 = dis_u64.clone();
+
+ let to_enum_i64 = enum_u64.clone();
+ let to_var_i64 = var_u64.clone();
+ let to_dis_i64 = dis_u64.clone();
+
+ TokenStream::from(quote::quote! {
+ impl ::num_traits::FromPrimitive for #name {
+ fn from_u64(val: u64) -> Option<Self> {
+ match val as _ {
+ #( #dis_u64 => Some(#enum_u64::#var_u64), )*
+ _ => None,
+ }
+ }
+
+ fn from_i64(val: i64) -> Option<Self> {
+ match val as _ {
+ #( #dis_i64 => Some(#enum_i64::#var_i64), )*
+ _ => None,
+ }
+ }
+ }
+
+ impl ::num_traits::ToPrimitive for #to_name {
+ fn to_u64(&self) -> Option<u64> {
+ match *self {
+ #( #to_enum_u64::#to_var_u64 => Some(#to_dis_u64 as u64), )*
+ }
+ }
+
+ fn to_i64(&self) -> Option<i64> {
+ match *self {
+ #( #to_enum_i64::#to_var_i64 => Some(#to_dis_i64 as i64), )*
+ }
+ }
+ }
+
+ impl ::core::convert::TryFrom<u64> for #to_name {
+ type Error = &'static str;
+
+ fn try_from(value: u64) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_u64(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<u32> for #to_name {
+ type Error = &'static str;
+
+ fn try_from(value: u32) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_u32(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<u16> for #to_name {
+ type Error = &'static str;
+
+ fn try_from(value: u16) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_u16(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<u8> for #to_name {
+ type Error = &'static str;
+
+ fn try_from(value: u8) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_u8(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<i64> for #name {
+ type Error = &'static str;
+
+ fn try_from(value: i64) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_i64(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<i32> for #name {
+ type Error = &'static str;
+
+ fn try_from(value: i32) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_i32(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<i16> for #name {
+ type Error = &'static str;
+
+ fn try_from(value: i16) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_i16(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+
+ impl ::core::convert::TryFrom<i8> for #name {
+ type Error = &'static str;
+
+ fn try_from(value: i8) -> ::core::result::Result<Self, Self::Error> {
+ use ::num_traits::FromPrimitive;
+
+ #to_name::from_i8(value).ok_or_else(|| "Unknown variant")
+ }
+ }
+ })
+ } else {
+ panic!("#[derive(Primitive)] is only valid for C-like enums");
+ }
+}