wiwi_memory_usage/impls/
range.rs

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

wiwi_memory_usage/impls/
range.rs
