Crate derive_tools

Expand description

§Module :: `derive_tools`

§Basic use-case

{
  use derive_tools::*;

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

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

  // derived From
  let src : Struct1 = ( 1, 3 ).into();
  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

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
dependency: Namespace with dependencies.
exposed: Exposed namespace of the module.
orphan: Orphan namespace of the module.
own: Own namespace of the module.
prelude: Prelude to use essentials: use my_module::prelude::*.
variadic: Module :: variadic_from

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§

Add: The addition operator +.
AddAssign: The addition assignment operator +=.
AsStaticRefDeprecated: A cheap reference-to-reference conversion. Used to convert a value to a reference value with 'static lifetime within generic code.
CloneDyn: A trait to upcast a clonable entity and clone it. It’s implemented for all entities which can be cloned.
Div: The division operator /.
DivAssign: The division assignment operator /=.
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.
Error: Error is a trait representing the basic expectations for error values, i.e., values of type E in Result<T, E>.
From1: Constructor with single argument.
From2: Constructor with two arguments.
From3: Constructor with three arguments.
Into: A value-to-value conversion that consumes the input value. The opposite of From.
Into1: value-to-value conversion that consumes the input value. Change left and rught, but keep semantic of `From1``.
IntoEnumIterator: This trait designates that an Enum can be iterated over. It can be auto generated using strum_macros on your behalf.
IntoIterator: Conversion into an Iterator.
Mul: The multiplication operator *.
MulAssign: The multiplication assignment operator *=.
Sub: The subtraction operator -.
SubAssign: The subtraction assignment operator -=.
Sum: Trait to represent types that can be created by summing up an iterator.
TryInto: An attempted conversion that consumes self, which may or may not be expensive.
VariantIterator
VariantMetadata
VariantNames: A trait for retrieving the names of each variant in Enum. This trait can be autoderived by strum_macros.

Functions§

clone: True clone which is applicable not only to clonable entities, but to trait objects implementing CloneDyn.
clone_into_box: Clone boxed dyn.

Attribute Macros§

clone_dyn: Derive macro to generate former for a structure. Former is variation of Builder Pattern.
phantom: Provides an automatic PhantomData field for a struct based on its generic types.

Derive Macros§

Add: What #[derive(Add)] generates
AddAssign: What #[derive(AddAssign)] generates
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
Constructor: What #[derive(Constructor)] generates
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
Div: What #[derive(Mul)] generates
DivAssign: What #[derive(MulAssign)] generates
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.
Error: Using #[derive(Error)]
From: Provides an automatic From implementation for struct wrapping a single value.
FromRepr: Add a function to enum that allows accessing variants by its discriminant
FromStr
Index: Provides an automatic Index trait implementation when-ever it’s possible.
IndexMut: Provides an automatic IndexMut trait implementation when-ever it’s possible.
InnerFrom: Derive macro to implement From converting outer type into inner when-ever it’s possible to do automatically.
Into: What #[derive(Into)] generates
IntoIterator: Using #[derive(IntoIterator)]
IntoStaticStr: Implements From<MyEnum> for &'static str on an enum.
IsVariant: What #[derive(IsVariant)] generates
Mul: What #[derive(Mul)] generates
MulAssign: What #[derive(MulAssign)] generates
New: Provides an automatic new implementation for struct wrapping a single value.
Not: Provides an automatic Not trait implementation for struct.
Sub: What #[derive(Add)] generates
SubAssign: What #[derive(AddAssign)] generates
Sum: Using #[derive(Sum)]
ToString: implements std::string::ToString on an enum
TryInto: What #[derive(TryInto)] generates
Unwrap: What #[derive(Unwrap)] generates
VariadicFrom: The derive_variadic_from macro is designed to provide a way to implement the From-like traits for structs with a variable number of fields, allowing them to be constructed from tuples of different lengths or from individual arguments. This functionality is particularly useful for creating flexible constructors that enable different methods of instantiation for a struct. By automating the implementation of traits, this macro reduces boilerplate code and enhances code readability and maintainability.

Crate derive_toolsCopy item path

§Module :: derive_tools

§Basic use-case

§To add to your project

§Try out from the repository

Modules§

Macros§

Enums§

Traits§

Functions§

Attribute Macros§

Derive Macros§

Crate derive_tools

§Module :: `derive_tools`