derive_more 1.0.0-beta.3

Adds #[derive(x)] macros for more traits
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#![cfg_attr(not(feature = "std"), no_std)]
#![allow(dead_code)]

#[cfg(not(feature = "std"))]
extern crate alloc;

#[cfg(not(feature = "std"))]
use alloc::{string::String, vec, vec::Vec};
use core::ptr;

use derive_more::AsMut;

#[derive(AsMut)]
struct SingleFieldTuple(String);

#[test]
fn single_field_tuple() {
    let mut item = SingleFieldTuple("test".into());

    assert!(ptr::eq(&mut item.0, item.as_mut()));
}

#[derive(AsMut)]
#[as_mut(forward)]
struct SingleFieldForward(Vec<i32>);

#[test]
fn single_field_forward() {
    let mut item = SingleFieldForward(vec![]);
    let _: &mut [i32] = (&mut item).as_mut();
}

#[derive(AsMut)]
struct SingleFieldStruct {
    first: String,
}

#[test]
fn single_field_struct() {
    let mut item = SingleFieldStruct {
        first: "test".into(),
    };

    assert!(ptr::eq(&mut item.first, item.as_mut()));
}

#[cfg(feature = "std")]
mod pathbuf {
    use std::path::PathBuf;

    use super::*;

    #[derive(AsMut)]
    struct MultiFieldTuple(#[as_mut] String, #[as_mut] PathBuf, Vec<usize>);

    #[test]
    fn multi_field_tuple() {
        let mut item = MultiFieldTuple("test".into(), PathBuf::new(), vec![]);

        assert!(ptr::eq(&mut item.0, item.as_mut()));
        assert!(ptr::eq(&mut item.1, item.as_mut()));
    }

    #[derive(AsMut)]
    struct MultiFieldStruct {
        #[as_mut]
        first: String,
        #[as_mut]
        second: PathBuf,
        third: Vec<usize>,
    }

    #[test]
    fn multi_field_struct() {
        let mut item = MultiFieldStruct {
            first: "test".into(),
            second: PathBuf::new(),
            third: vec![],
        };

        assert!(ptr::eq(&mut item.first, item.as_mut()));
        assert!(ptr::eq(&mut item.second, item.as_mut()));
    }

    #[derive(AsMut)]
    struct MultiFieldGenericStruct<T> {
        #[as_mut]
        first: Vec<T>,
        #[as_mut]
        second: PathBuf,
        third: Vec<usize>,
    }

    #[test]
    fn multi_field_generic_struct() {
        let mut item = MultiFieldGenericStruct {
            first: b"test".to_vec(),
            second: PathBuf::new(),
            third: vec![],
        };

        assert!(ptr::eq(&mut item.first, item.as_mut()));
        assert!(ptr::eq(&mut item.second, item.as_mut()));
    }
}

#[derive(AsMut)]
struct SingleFieldGenericStruct<T> {
    first: T,
}

#[test]
fn single_field_generic_struct() {
    let mut item = SingleFieldGenericStruct { first: "test" };

    assert!(ptr::eq(&mut item.first, item.as_mut()));
}