enum-primitive-derive-0.1.2/.gitignore01006440000765000002400000000032131515662370016153 0ustar0000000000000000target Cargo.lock *.rs.bk enum-primitive-derive-0.1.2/.gitlab-ci.yml01006440000765000002400000001107131516244250016615 0ustar0000000000000000stages: - build build-1_15: stage: build image: scorpil/rust:1.15.1 dependencies: [] script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose build-beta: stage: build image: scorpil/rust:beta dependencies: [] script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose build-nightly: stage: build image: scorpil/rust:nightly dependencies: [] script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose enum-primitive-derive-0.1.2/Cargo.toml01006440000765000002400000002253131520761260016114 0ustar0000000000000000# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "enum-primitive-derive" version = "0.1.2" authors = ["Doug Goldstein "] description = "enum_primitive implementation using procedural macros to have a custom derive" homepage = "https://gitlab.com/cardoe/enum-primitive-derive" readme = "README.md" keywords = ["derive", "enum", "fromprimitive", "primitive", "ffi"] categories = ["rust-patterns"] license = "MIT" repository = "https://gitlab.com/cardoe/enum-primitive-derive.git" [lib] proc-macro = true [dependencies.num-traits] version = "^0.1" [dependencies.quote] version = "^0.3" [dependencies.syn] version = "^0.11" [badges.gitlab] repository = "cardoe/enum-primitive-derive" enum-primitive-derive-0.1.2/Cargo.toml.orig01006440000765000002400000001211131520761260017044 0ustar0000000000000000[package] name = "enum-primitive-derive" version = "0.1.2" authors = ["Doug Goldstein "] license = "MIT" description = "enum_primitive implementation using procedural macros to have a custom derive" readme = "README.md" homepage = "https://gitlab.com/cardoe/enum-primitive-derive" repository = "https://gitlab.com/cardoe/enum-primitive-derive.git" keywords = ["derive", "enum", "fromprimitive", "primitive", "ffi"] categories = ["rust-patterns"] changelog = "CHANGELOG.md" [badges] gitlab = { repository = "cardoe/enum-primitive-derive" } [lib] proc-macro = true [dependencies] num-traits = "^0.1" quote = "^0.3" syn = "^0.11" enum-primitive-derive-0.1.2/CHANGELOG.md01006440000765000002400000000255131520753410015773 0ustar0000000000000000# ChangeLog ## 0.1.2 ### Changed - drop `extern crate core;` as core is unused ## 0.1.1 ### Added - Support for more casts on discriminants ## 0.1.0 Initial version enum-primitive-derive-0.1.2/LICENSE01006440000765000002400000002076131515776750015212 0ustar0000000000000000Copyright (c) 2017 Doug Goldstein 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. enum-primitive-derive-0.1.2/README.md01006440000765000002400000004247131520372410015443 0ustar0000000000000000# enum-primitive-derive This is a custom derive, using procedural macros, implementation of [enum_primitive](https://crates.io/crates/enum_primitive). ## Documentation https:/docs.rs/enum-primitive-derive/ ## Usage Add the following to `Cargo.toml`: ``` [dependencies] enum-primitive-derive = "^0.1" num-traits = "^0.1" ``` Then to your code add: ```rust #[macro_use] extern crate enum_primitive_derive; extern crate num_traits; #[derive(Primitive)] enum Variant { Value = 1, Another = 2, } ``` To be really useful you need `use num_traits::FromPrimitive` or `use num_traits::ToPrimitive` or both. You will then be able to use [num_traits::FromPrimitive](https://rust-num.github.io/num/num/trait.FromPrimitive.html) and/or [num_traits::ToPrimitive](https://rust-num.github.io/num/num/trait.ToPrimitive.html) on your enum. ## Full Example ```rust #[macro_use] extern crate enum_primitive_derive; extern crate num_traits; use num_traits::{FromPrimitive, ToPrimitive}; #[derive(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 In this case we attempt to use values created by [bindgen](https://crates.io/crates/bindgen). ```rust #[macro_use] extern crate enum_primitive_derive; extern crate num_traits; 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)); } ``` enum-primitive-derive-0.1.2/src/lib.rs01006440000765000002400000014063131520752760016076 0ustar0000000000000000// Copyright (c) 2017 Doug Goldstein // 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 //! #[macro_use] //! extern crate enum_primitive_derive; //! extern crate num_traits; //! //! 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 //! #[macro_use] //! extern crate enum_primitive_derive; //! extern crate num_traits; //! //! 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)); //! } //! ``` extern crate proc_macro; extern crate num_traits; #[macro_use] extern crate quote; extern crate syn; use proc_macro::TokenStream; /// Provides implementation of `num_traits::ToPrimitive` and /// `num_traits::FromPrimitive` #[proc_macro_derive(Primitive)] pub fn primitive(input: TokenStream) -> TokenStream { // Construct a string representation of the type definition let s = input.to_string(); // Parse the string representation let ast = syn::parse_derive_input(&s).unwrap(); // Build the impl let gen = impl_primitive(&ast); // Return the generated impl gen.parse().unwrap() } fn impl_primitive(ast: &syn::DeriveInput) -> quote::Tokens { let name = &ast.ident; // Check if derive(Primitive) was specified for a struct if let syn::Body::Enum(ref variant) = ast.body { let (var_u64, dis_u64): (Vec<_>, Vec<_>) = variant.iter().map(|v| { if v.data != syn::VariantData::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().unwrap() { syn::ConstExpr::Cast(real, _) => *real, orig => orig, }; (v.ident.clone(), discrim) }).unzip(); // quote!{} needs this to be a vec since its in #( )* let enum_u64 = vec![name.clone(); variant.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(); quote! { impl ::num_traits::FromPrimitive for #name { fn from_u64(val: u64) -> Option { match val as _ { #( #dis_u64 => Some(#enum_u64::#var_u64), )* _ => None, } } fn from_i64(val: i64) -> Option { match val as _ { #( #dis_i64 => Some(#enum_i64::#var_i64), )* _ => None, } } } impl ::num_traits::ToPrimitive for #to_name { fn to_u64(&self) -> Option { match *self { #( #to_enum_u64::#to_var_u64 => Some(#to_dis_u64 as u64), )* } } fn to_i64(&self) -> Option { match *self { #( #to_enum_i64::#to_var_i64 => Some(#to_dis_i64 as i64), )* } } } } } else { panic!("#[derive(Primitive)] is only valid for C-like enums"); } }