1use super::*;
2
3#[cfg(target_pointer_width = "16")]
4mod platform_dependent {
5 use super::*;
6
7 impl ToU8 for usize {
8 fn to_u8(self) -> u8 {
9 if self & 0xff00 != 0 {
10 u8::MAX
11 } else {
12 self as u8
13 }
14 }
15 }
16 impl AsU16 for usize {
17 fn as_u16(self) -> u16 {
18 self as u16
19 }
20 }
21 impl AsU32 for usize {
22 fn as_u32(self) -> u32 {
23 (self as u16).into()
24 }
25 }
26 impl AsU64 for usize {
27 fn as_u64(self) -> u64 {
28 (self as u16).into()
29 }
30 }
31 impl AsU128 for usize {
32 fn as_u128(self) -> u128 {
33 (self as u16).into()
34 }
35 }
36
37 impl ToI8 for usize {
38 fn to_i8(self) -> i8 {
39 if self & 0xff80 != 0 {
40 i8::MAX
41 } else {
42 self as i8
43 }
44 }
45 }
46 impl AsI16 for usize {
47 fn as_i16(self) -> i16 {
48 if self & 0x8000 != 0 {
49 i16::MAX
50 } else {
51 self as i16
52 }
53 }
54 }
55 impl AsI32 for usize {
56 fn as_i32(self) -> i32 {
57 (self as u16).into()
58 }
59 }
60 impl AsI64 for usize {
61 fn as_i64(self) -> i64 {
62 (self as u16).into()
63 }
64 }
65 impl AsI128 for usize {
66 fn as_i128(self) -> i128 {
67 (self as u16).into()
68 }
69 }
70
71 impl AsF32 for usize {
72 fn as_f32(self) -> f32 {
73 (self as u16).into()
74 }
75 }
76 impl AsF64 for usize {
77 fn as_f64(self) -> f64 {
78 (self as u16).into()
79 }
80 }
81}
82
83#[cfg(target_pointer_width = "32")]
84mod platform_dependent {
85 use super::*;
86
87 impl ToU8 for usize {
88 fn to_u8(self) -> u8 {
89 if self & 0xffff_ff00 != 0 {
90 u8::MAX
91 } else {
92 self as u8
93 }
94 }
95 }
96 impl AsU16 for usize {
97 fn as_u16(self) -> u16 {
98 if self & 0xffff_0000 != 0 {
99 u16::MAX
100 } else {
101 self as u16
102 }
103 }
104 }
105 impl AsU32 for usize {
106 fn as_u32(self) -> u32 {
107 self as u32
108 }
109 }
110 impl AsU64 for usize {
111 fn as_u64(self) -> u64 {
112 (self as u32).into()
113 }
114 }
115 impl AsU128 for usize {
116 fn as_u128(self) -> u128 {
117 (self as u32).into()
118 }
119 }
120
121 impl ToI8 for usize {
122 fn to_i8(self) -> i8 {
123 if self & 0xffff_ff80 != 0 {
124 i8::MAX
125 } else {
126 self as i8
127 }
128 }
129 }
130 impl AsI16 for usize {
131 fn as_i16(self) -> i16 {
132 if self & 0xffff_8000 != 0 {
133 i16::MAX
134 } else {
135 self as i16
136 }
137 }
138 }
139 impl ToI32 for usize {
140 fn to_i32(self) -> i32 {
141 if self & 0x8000_0000 != 0 {
142 i32::MAX
143 } else {
144 self as i32
145 }
146 }
147 }
148 impl AsI64 for usize {
149 fn as_i64(self) -> i64 {
150 (self as u32).into()
151 }
152 }
153 impl AsI128 for usize {
154 fn as_i128(self) -> i128 {
155 (self as u32).into()
156 }
157 }
158
159 impl ToF32 for usize {
160 fn to_f32(self) -> f32 {
161 self as f32
162 }
163 }
164 impl AsF64 for usize {
165 fn as_f64(self) -> f64 {
166 (self as u32).into()
167 }
168 }
169}
170
171#[cfg(target_pointer_width = "64")]
172mod platform_dependent {
173 use super::*;
174
175 impl ToU8 for usize {
176 fn to_u8(self) -> u8 {
177 if self & 0xffff_ffff_ffff_ff00 != 0 {
178 u8::MAX
179 } else {
180 self as u8
181 }
182 }
183 }
184 impl AsU16 for usize {
185 fn as_u16(self) -> u16 {
186 if self & 0xffff_ffff_ffff_0000 != 0 {
187 u16::MAX
188 } else {
189 self as u16
190 }
191 }
192 }
193 impl ToU32 for usize {
194 fn to_u32(self) -> u32 {
195 if self & 0xffff_ffff_0000_0000 != 0 {
196 u32::MAX
197 } else {
198 self as u32
199 }
200 }
201 }
202 impl AsU64 for usize {
203 fn as_u64(self) -> u64 {
204 self as u64
205 }
206 }
207 impl AsU128 for usize {
208 fn as_u128(self) -> u128 {
209 (self as u64).into()
210 }
211 }
212
213 impl ToI8 for usize {
214 fn to_i8(self) -> i8 {
215 if self & 0xffff_ffff_ffff_ff80 != 0 {
216 i8::MAX
217 } else {
218 self as i8
219 }
220 }
221 }
222 impl AsI16 for usize {
223 fn as_i16(self) -> i16 {
224 if self & 0xffff_ffff_ffff_8000 != 0 {
225 i16::MAX
226 } else {
227 self as i16
228 }
229 }
230 }
231 impl ToI32 for usize {
232 fn to_i32(self) -> i32 {
233 if self & 0xffff_ffff_8000_0000 != 0 {
234 i32::MAX
235 } else {
236 self as i32
237 }
238 }
239 }
240 impl AsI64 for usize {
241 fn as_i64(self) -> i64 {
242 if self & 0x8000_0000_0000_0000 != 0 {
243 i64::MAX
244 } else {
245 self as i64
246 }
247 }
248 }
249 impl AsI128 for usize {
250 fn as_i128(self) -> i128 {
251 (self as u64).into()
252 }
253 }
254
255 impl ToF32 for usize {
256 fn to_f32(self) -> f32 {
257 self as f32
258 }
259 }
260 impl ToF64 for usize {
261 fn to_f64(self) -> f64 {
262 self as f64
263 }
264 }
265}