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