wiwi_memory_usage/impls/
range.rs

1use crate::{ MemoryUsage, MemoryUsageStatic };
2use crate::macros::{
3	impl_memory_usage,
4	impl_memory_usage_only_static,
5	impl_memory_usage_size_of
6};
7use core::ops::{
8	Range,
9	RangeFrom,
10	RangeFull,
11	RangeInclusive,
12	RangeTo,
13	RangeToInclusive
14};
15#[cfg(feature = "nightly")]
16use core::range::{
17	Range as RangeNew,
18	RangeFrom as RangeFromNew,
19	// this is the same type as from core::ops, for some reason
20	// RangeFull as RangeFullNew,
21	RangeInclusive as RangeInclusiveNew,
22	// RangeTo is same as RangeFull, for some reason
23	// RangeTo as RangeToNew,
24	RangeToInclusive as RangeToInclusiveNew
25};
26
27impl_memory_usage_size_of! {
28	RangeFull
29}
30
31impl_memory_usage! {
32	{ Idx: MemoryUsage }
33	{ Idx: [const] MemoryUsage }
34	Range<Idx>
35	|self| self.start.memory_usage() + self.end.memory_usage();
36	compacted |self| self.start.memory_usage_compacted() + self.end.memory_usage_compacted();
37	compact |self| self.start.compact_memory() + self.end.compact_memory();
38	ref compacted |self| self.start.memory_usage_compacted_ref() + self.end.memory_usage_compacted_ref();
39	ref compact |self| self.start.compact_memory_ref() + self.end.compact_memory_ref();
40}
41
42impl_memory_usage_only_static! {
43	{ Idx: MemoryUsageStatic }
44	{ Idx: [const] MemoryUsageStatic }
45	Range<Idx>
46	=> Idx::MEMORY_USAGE * 2;
47}
48
49#[cfg(feature = "nightly")]
50impl_memory_usage! {
51	{ Idx: MemoryUsage }
52	{ Idx: [const] MemoryUsage }
53	RangeNew<Idx>
54	|self| self.start.memory_usage() + self.end.memory_usage();
55	compacted |self| self.start.memory_usage_compacted() + self.end.memory_usage_compacted();
56	compact |self| self.start.compact_memory() + self.end.compact_memory();
57	ref compacted |self| self.start.memory_usage_compacted_ref() + self.end.memory_usage_compacted_ref();
58	ref compact |self| self.start.compact_memory_ref() + self.end.compact_memory_ref();
59}
60
61#[cfg(feature = "nightly")]
62impl_memory_usage_only_static! {
63	{ Idx: MemoryUsageStatic }
64	{ Idx: [const] MemoryUsageStatic }
65	RangeNew<Idx>
66	=> Idx::MEMORY_USAGE * 2;
67}
68
69impl_memory_usage! {
70	{ Idx: MemoryUsage }
71	{ Idx: [const] MemoryUsage }
72	RangeInclusive<Idx>
73	|self| {
74		let start = self.start().memory_usage();
75		let end = self.end().memory_usage();
76		// could just take size of bool, but that's not guaranteed to be there, so
77		// roundabout calculating it instead
78		let remaining = size_of::<RangeInclusive<Idx>>() - (2 * size_of::<Idx>());
79		start + end + remaining
80	};
81	ref compacted |self| {
82		let start = self.start().memory_usage_compacted_ref();
83		let end = self.end().memory_usage_compacted_ref();
84		let remaining = size_of::<RangeInclusive<Idx>>() - (2 * size_of::<Idx>());
85		start + end + remaining
86	};
87	ref compact |self| self.start().compact_memory_ref() + self.end().compact_memory_ref();
88}
89
90impl_memory_usage_only_static! {
91	{ Idx: MemoryUsageStatic }
92	{ Idx: [const] MemoryUsageStatic }
93	RangeInclusive<Idx>
94	=> {
95		let start = Idx::MEMORY_USAGE;
96		let end = Idx::MEMORY_USAGE;
97		// could just take size of bool, but that's not guaranteed to be there, so
98		// roundabout calculating it instead
99		let remaining = size_of::<RangeInclusive<Idx>>() - (2 * size_of::<Idx>());
100		start + end + remaining
101	};
102}
103
104#[cfg(feature = "nightly")]
105impl_memory_usage! {
106	{ Idx: MemoryUsage }
107	{ Idx: [const] MemoryUsage }
108	RangeInclusiveNew<Idx>
109	|self| self.start.memory_usage() + self.last.memory_usage();
110	compacted |self| self.start.memory_usage_compacted() + self.last.memory_usage_compacted();
111	compact |self| self.start.compact_memory() + self.last.compact_memory();
112	ref compacted |self| self.start.memory_usage_compacted_ref() + self.last.memory_usage_compacted_ref();
113	ref compact |self| self.start.compact_memory_ref() + self.last.compact_memory_ref();
114}
115
116#[cfg(feature = "nightly")]
117impl_memory_usage_only_static! {
118	{ Idx: MemoryUsageStatic }
119	{ Idx: [const] MemoryUsageStatic }
120	RangeInclusiveNew<Idx>
121	=> Idx::MEMORY_USAGE * 2;
122}
123
124impl_memory_usage! {
125	{ Idx: MemoryUsage }
126	{ Idx: [const] MemoryUsage }
127	RangeFrom<Idx>
128	|self| self.start.memory_usage();
129	compacted |self| self.start.memory_usage_compacted();
130	compact |self| self.start.compact_memory();
131	ref compacted |self| self.start.memory_usage_compacted_ref();
132	ref compact |self| self.start.compact_memory_ref();
133}
134
135impl_memory_usage_only_static! {
136	{ Idx: MemoryUsageStatic }
137	{ Idx: [const] MemoryUsageStatic }
138	RangeFrom<Idx>
139	=> Idx::MEMORY_USAGE;
140}
141
142#[cfg(feature = "nightly")]
143impl_memory_usage! {
144	{ Idx: MemoryUsage }
145	{ Idx: [const] MemoryUsage }
146	RangeFromNew<Idx>
147	|self| self.start.memory_usage();
148	compacted |self| self.start.memory_usage_compacted();
149	compact |self| self.start.compact_memory();
150	ref compacted |self| self.start.memory_usage_compacted_ref();
151	ref compact |self| self.start.compact_memory_ref();
152}
153
154#[cfg(feature = "nightly")]
155impl_memory_usage_only_static! {
156	{ Idx: MemoryUsageStatic }
157	{ Idx: [const] MemoryUsageStatic }
158	RangeFromNew<Idx>
159	=> Idx::MEMORY_USAGE;
160}
161
162impl_memory_usage! {
163	{ Idx: MemoryUsage }
164	{ Idx: [const] MemoryUsage }
165	RangeTo<Idx>
166	|self| self.end.memory_usage();
167	compacted |self| self.end.memory_usage_compacted();
168	compact |self| self.end.compact_memory();
169	ref compacted |self| self.end.memory_usage_compacted_ref();
170	ref compact |self| self.end.compact_memory_ref();
171}
172
173impl_memory_usage_only_static! {
174	{ Idx: MemoryUsageStatic }
175	{ Idx: [const] MemoryUsageStatic }
176	RangeTo<Idx>
177	=> Idx::MEMORY_USAGE;
178}
179
180impl_memory_usage! {
181	{ Idx: MemoryUsage }
182	{ Idx: [const] MemoryUsage }
183	RangeToInclusive<Idx>
184	|self| self.end.memory_usage();
185	compacted |self| self.end.memory_usage_compacted();
186	compact |self| self.end.compact_memory();
187	ref compacted |self| self.end.memory_usage_compacted_ref();
188	ref compact |self| self.end.compact_memory_ref();
189}
190
191impl_memory_usage_only_static! {
192	{ Idx: MemoryUsageStatic }
193	{ Idx: [const] MemoryUsageStatic }
194	RangeToInclusive<Idx>
195	=> Idx::MEMORY_USAGE;
196}
197
198#[cfg(feature = "nightly")]
199impl_memory_usage! {
200	{ Idx: MemoryUsage }
201	{ Idx: [const] MemoryUsage }
202	RangeToInclusiveNew<Idx>
203	|self| self.last.memory_usage();
204	compacted |self| self.last.memory_usage_compacted();
205	compact |self| self.last.compact_memory();
206	ref compacted |self| self.last.memory_usage_compacted_ref();
207	ref compact |self| self.last.compact_memory_ref();
208}
209
210#[cfg(feature = "nightly")]
211impl_memory_usage_only_static! {
212	{ Idx: MemoryUsageStatic }
213	{ Idx: [const] MemoryUsageStatic }
214	RangeToInclusiveNew<Idx>
215	=> Idx::MEMORY_USAGE;
216}
217
218#[cfg(test)]
219mod tests {
220	use super::*;
221
222	#[test]
223	fn range_full_usage() {
224		let range: RangeFull = ..;
225
226		assert_eq!(range.memory_usage(), 0);
227		assert_eq!(RangeFull::MEMORY_USAGE, 0);
228	}
229
230	#[test]
231	fn range_usage() {
232		let range: Range<usize> = 0..10;
233
234		assert_eq!(range.memory_usage(), 16);
235		assert_eq!(<Range<usize>>::MEMORY_USAGE, 16);
236	}
237
238	#[cfg(feature = "nightly")]
239	#[test]
240	fn range_new_usage() {
241		let range: RangeNew<usize> = (0..10).into();
242
243		assert_eq!(range.memory_usage(), 16);
244		assert_eq!(<Range<usize>>::MEMORY_USAGE, 16);
245	}
246
247	#[test]
248	fn range_inclusive_usage() {
249		let range: RangeInclusive<usize> = 0..=10;
250
251		assert_eq!(range.memory_usage(), 24);
252		assert_eq!(<RangeInclusive<usize>>::MEMORY_USAGE, 24);
253	}
254
255	#[cfg(feature = "nightly")]
256	#[test]
257	fn range_inclusive_new_usage() {
258		let range: RangeInclusiveNew<usize> = (0..=10).into();
259
260		assert_eq!(range.memory_usage(), 16);
261		assert_eq!(<RangeInclusiveNew<usize>>::MEMORY_USAGE, 16);
262	}
263
264	#[test]
265	fn range_from_usage() {
266		let range: RangeFrom<usize> = 0..;
267
268		assert_eq!(range.memory_usage(), 8);
269		assert_eq!(<RangeFrom<usize>>::MEMORY_USAGE, 8);
270	}
271
272	#[cfg(feature = "nightly")]
273	#[test]
274	fn range_from_new_usage() {
275		let range: RangeFromNew<usize> = (0..).into();
276
277		assert_eq!(range.memory_usage(), 8);
278		assert_eq!(<RangeFrom<usize>>::MEMORY_USAGE, 8);
279	}
280
281	#[test]
282	fn range_to_usage() {
283		let range: RangeTo<usize> = ..10;
284
285		assert_eq!(range.memory_usage(), 8);
286		assert_eq!(<RangeTo<usize>>::MEMORY_USAGE, 8);
287	}
288
289	#[test]
290	fn range_to_inclusive_usage() {
291		let range: RangeToInclusive<usize> = ..=10;
292
293		assert_eq!(range.memory_usage(), 8);
294		assert_eq!(<RangeToInclusive<usize>>::MEMORY_USAGE, 8);
295	}
296
297	#[cfg(feature = "nightly")]
298	#[test]
299	fn range_to_inclusive_new_usage() {
300		let range: RangeToInclusiveNew<usize> = (..=10).into();
301
302		assert_eq!(range.memory_usage(), 8);
303		assert_eq!(<RangeToInclusiveNew<usize>>::MEMORY_USAGE, 8);
304	}
305}
wiwi_memory_usage/impls/range.rs

wiwi_memory_usage/impls/
range.rs
