Crate derive_tools

Collection of derives which extend STD.

Module :: derive_tools

Collection of derives which extend STD.

Basic use-case

#[ cfg( all( feature = "derive_from", feature = "derive_into", feature = "derive_display", feature = "derive_from_str" ) ) ]
{
  use derive_tools::*;

  #[ derive( Into, Display, FromStr, PartialEq, Debug ) ]
  #[ display( "{a}-{b}" ) ]
  struct Struct1
  {
    a : i32,
    b : i32,
  }

  // derived Into
  let src = Struct1 { a : 1, b : 3 };
  let got : ( i32, i32 ) = src.into();
  let exp = ( 1, 3 );
  assert_eq!( got, exp );

  // derived Display
  let src = Struct1 { a : 1, b : 3 };
  let got = format!( "{}", src );
  let exp = "1-3";
  println!( "{}", got );
  assert_eq!( got, exp );

  // derived FromStr
  use std::str::FromStr;
  let src = Struct1::from_str( "1-3" );
  let exp = Ok( Struct1 { a : 1, b : 3 } );
  assert_eq!( src, exp );
}

To add to your project

cargo add derive_tools

Try out from the repository

git clone https://github.com/Wandalen/wTools
cd wTools
cd examples/derive_tools_trivial
cargo run

Re-exports

• pub use super::wtools;

Modules

• _private_phf_reexport_for_macro_if_phf_feature
  Rust-PHF is a library to generate efficient lookup tables at compile time using perfect hash functions.
• additional_attributes
  Documentation for Additional Attributes
• clone_dyn
  Derive to clone dyn structures.
• dependency
  Dependencies.
• exposed
  Exposed namespace of the module.
• orphan
  Orphan namespace of the module.
• prelude
  Prelude to use essentials: use my_module::prelude::*.
• protected
  Protected namespace of the module.
• reflect
  System of Types for Reflection
• wtools
  Types, which are extension of std.

Macros

• from
  Variadic constructor.

Enums

• ParseError
  The ParseError enum is a collection of all the possible reasons an enum can fail to parse from a string.

Traits

• AsStaticRefDeprecated
  A cheap reference-to-reference conversion. Used to convert a value to a reference value with 'static lifetime within generic code.
• EnumCount
  A trait for capturing the number of variants in Enum. This trait can be autoderived by strum_macros.
• EnumMessage
  Associates additional pieces of information with an Enum. This can be autoimplemented by deriving EnumMessage and annotating your variants with #[strum(message="...")].
• EnumProperty
  EnumProperty is a trait that makes it possible to store additional information with enum variants. This trait is designed to be used with the macro of the same name in the strum_macros crate. Currently, the only string literals are supported in attributes, the other methods will be implemented as additional attribute types become stabilized.
• From_0
  Constructor without arguments. Alias of Default.
• From_1
  Constructor with single argument.
• From_2
  Constructor with two arguments.
• From_3
  Constructor with three arguments.
• Into1
  value-to-value conversion that consumes the input value. Change left and rught, but keep semantic of `From_1``.
• IntoEnumIterator
  This trait designates that an Enum can be iterated over. It can be auto generated using strum_macros on your behalf.
• VariantIterator
• VariantMetadata
• VariantNames
  A trait for retrieving the names of each variant in Enum. This trait can be autoderived by strum_macros.

Functions

• _clone_boxed
  Clone boxed dyn.
• reflect
  Provides a reflection of an instance that implements the Instance trait.

Attribute Macros

• clone_dyn
  Derive macro to generate former for a structure. Former is variation of Builder Pattern.

Derive Macros

• AsMut
  Derive macro to implement AsMut when-ever it’s possible to do automatically.
• AsRef
  Derive macro to implement AsRef when-ever it’s possible to do automatically.
• AsRefStr
  Converts enum variants to &'static str.
• AsStaticStr
• Deref
  Derive macro to implement Deref when-ever it’s possible to do automatically.
• DerefMut
  Derive macro to implement Deref when-ever it’s possible to do automatically.
• Display
• EnumCount
  Add a constant usize equal to the number of variants.
• EnumDiscriminants
  Generate a new type with only the discriminant names.
• EnumIs
  Generated is_*() methods for each variant. E.g. Color.is_red().
• EnumIter
  Creates a new type that iterates of the variants of an enum.
• EnumMessage
  Add a verbose message to an enum variant.
• EnumProperty
  Add custom properties to enum variants.
• EnumString
  Converts strings to enum variants based on their name.
• EnumTryAs
  Generated try_as_*() methods for all tuple-style variants. E.g. Message.try_as_write().
• EnumVariantNames
  Implements Strum::VariantNames which adds an associated constant VARIANTS which is an array of discriminant names.
• From
  Derive macro to implement From converting inner type into outer when-ever it’s possible to do automatically.
• FromInner
  Derive macro to implement From converting inner type into outer when-ever it’s possible to do automatically.
• FromRepr
  Add a function to enum that allows accessing variants by its discriminant
• FromStr
• InnerFrom
  Derive macro to implement From converting outer type into inner when-ever it’s possible to do automatically.
• IntoStaticStr
  Implements From<MyEnum> for &'static str on an enum.
• Reflect
  Reflect structure of any kind.
• ToString
  implements std::string::ToString on an enum
• VariadicFrom
  Derive macro to implement default constructors From_0, From_1, From_2, From_3.