enum-primitive-derive-0.2.2/.cargo_vcs_info.json0000644000000001120000000000100152550ustar { "git": { "sha1": "bdb12f31b4ad96c0cc9d0d2fc3bf5c00ca2f4110" } } enum-primitive-derive-0.2.2/.gitignore000064400000000000000000000000320072674642500160660ustar 00000000000000target Cargo.lock *.rs.bk enum-primitive-derive-0.2.2/.gitlab-ci.yml000064400000000000000000000016360072674642500165450ustar 00000000000000stages: - build build-1_34: stage: build image: rust:1.34-slim dependencies: [] script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose build-stable: stage: build image: rust:latest dependencies: [] script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose build-beta: stage: build image: rust:latest dependencies: [] before_script: - rustup default beta script: - cargo build --verbose - cargo test --verbose - cargo doc --verbose build-nightly: stage: build image: rust:latest dependencies: [] before_script: - rustup default nightly script: - cargo generate-lockfile -Z minimal-versions - cargo build --verbose --locked - cargo test --verbose --locked - cargo doc --verbose --locked enum-primitive-derive-0.2.2/CHANGELOG.md000064400000000000000000000012020072674642500157070ustar 00000000000000# ChangeLog ## 0.2.2 ### Changed - Switch to using core instead of std for no-std support ## 0.2.1 ### Added - support TryFrom ## 0.2.0 (yanked) ### Changed - Upgrade [syn](https://crates.io/crates/syn) and [quote](https://crates.io/crates/quote) to 1.0 - add a better diagnostic for the case where a discriminant isn't specified for an enum - Move unnecessary [`num-traits`](https://crates.io/crates/num-traits) dependency to `dev-dependencies` - Migrate to Rust 2018 edition ## 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.2.2/Cargo.toml0000644000000022230000000000100132600ustar # 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 are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2018" name = "enum-primitive-derive" version = "0.2.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.2" default-features = false [dependencies.quote] version = "1" [dependencies.syn] version = "1" [badges.gitlab] repository = "cardoe/enum-primitive-derive" enum-primitive-derive-0.2.2/Cargo.toml.orig000064400000000000000000000012500072674642500167700ustar 00000000000000[package] name = "enum-primitive-derive" version = "0.2.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"] edition = "2018" [badges] gitlab = { repository = "cardoe/enum-primitive-derive" } [lib] proc-macro = true [dependencies] quote = "1" syn = "1" [dependencies.num-traits] version = "0.2" default-features = false enum-primitive-derive-0.2.2/LICENSE000064400000000000000000000020760072674642500151150ustar 00000000000000Copyright (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.2.2/README.md000064400000000000000000000056440072674642500153730ustar 00000000000000[![Build status](https://gitlab.com/cardoe/enum-primitive-derive/badges/master/pipeline.svg)](https://gitlab.com/cardoe/enum-primitive-derive/commits/master) [![Rust version]( https://img.shields.io/badge/rust-1.34+-blue.svg)]() [![Documentation](https://docs.rs/enum-primitive-derive/badge.svg)](https://docs.rs/enum-primitive-derive) [![Latest version](https://img.shields.io/crates/v/enum-primitive-derive.svg)](https://crates.io/crates/enum-primitive-derive) [![All downloads](https://img.shields.io/crates/d/enum-primitive-derive.svg)](https://crates.io/crates/enum-primitive-derive) [![Downloads of latest version](https://img.shields.io/crates/dv/enum-primitive-derive.svg)](https://crates.io/crates/enum-primitive-derive) This is a custom derive, using procedural macros, implementation of [enum_primitive](https://crates.io/crates/enum_primitive). MSRV is 1.34.0 ## Documentation [https://docs.rs/enum-primitive-derive/](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.2.2/src/lib.rs000064400000000000000000000223110072674642500160050ustar 00000000000000// 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 //! 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 { 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), )* } } } impl ::core::convert::TryFrom for #to_name { type Error = &'static str; fn try_from(value: u64) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_u64(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #to_name { type Error = &'static str; fn try_from(value: u32) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_u32(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #to_name { type Error = &'static str; fn try_from(value: u16) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_u16(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #to_name { type Error = &'static str; fn try_from(value: u8) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_u8(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #name { type Error = &'static str; fn try_from(value: i64) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_i64(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #name { type Error = &'static str; fn try_from(value: i32) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_i32(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #name { type Error = &'static str; fn try_from(value: i16) -> ::core::result::Result { use ::num_traits::FromPrimitive; #to_name::from_i16(value).ok_or_else(|| "Unknown variant") } } impl ::core::convert::TryFrom for #name { type Error = &'static str; fn try_from(value: i8) -> ::core::result::Result { 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"); } }