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

§Rule Compliance & Architectural Notes

This crate has been systematically updated to comply with the Design and Codestyle Rulebooks. Key compliance achievements:

§Completed Compliance Work:

Feature Architecture: All functionality is properly gated behind the “enabled” feature following the mandatory ‘enabled’ and ‘full’ features requirement.
Dependencies: Uses workspace dependency inheritance with { workspace = true }. All derive macro dependencies are centralized in the workspace Cargo.toml.
Attribute Formatting: All attributes use proper spacing per Universal Formatting Rule.
Documentation Strategy: Uses #![ doc = include_str!(...) ] to include readme.md instead of duplicating documentation.
Namespace Organization: Uses the standard own/orphan/exposed/prelude namespace pattern for controlled visibility and re-exports.

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: Dynamic cloning utilities
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: Variadic conversion utilities

Macros§

from: Macro to construct a struct from variadic arguments.

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: Trait for converting from one argument.
From2: Trait for converting from two arguments.
From3: Trait for converting from three arguments.
Into: A value-to-value conversion that consumes the input value. The opposite of From.
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 for CloneDyn trait.

Derive Macros§

Add: What #[derive(Add)] generates
AddAssign: What #[derive(AddAssign)] generates
AsMut: Implement AsMut for a structure.
AsRef: Implement AsRef for a structure.
AsRefStr: Converts enum variants to &'static str.
AsStaticStr
Constructor: What #[derive(Constructor)] generates
Deref: Implement Deref for a structure.
DerefMut: Implement DerefMut for a structure.
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: Implement From for a structure.
FromRepr: Add a function to enum that allows accessing variants by its discriminant
FromStr
Index: Implement Index for a structure.
IndexMut: Implement IndexMut for a structure.
InnerFrom: Implement InnerFrom for a structure.
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: Implement New for a structure.
Not: Implement Not for a structure.
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: Implement VariadicFrom for a structure.

Crate derive_toolsCopy item path

§Module :: derive_tools

§Basic use-case

§To add to your project

§Try out from the repository

§Rule Compliance & Architectural Notes

§Completed Compliance Work:

Modules§

Macros§

Enums§

Traits§

Functions§

Attribute Macros§

Derive Macros§

Crate derive_tools

§Module :: `derive_tools`