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()));
}
|
