1use crate::{Currency, CurrencyLocale};
2use std::ops::Mul;
3
4impl<L: CurrencyLocale + Default> Mul<usize> for Currency<L> {
5 type Output = Self;
6
7 fn mul(self, rhs: usize) -> Self::Output {
8 Self::new(
9 self.negative,
10 (self.amount as f64 * rhs as f64) as usize,
11 self.locale,
12 )
13 }
14}
15
16impl<L: CurrencyLocale + Default> Mul<Currency<L>> for usize {
17 type Output = Currency<L>;
18
19 fn mul(self, rhs: Currency<L>) -> Self::Output {
20 rhs * self
21 }
22}
23
24impl<L: CurrencyLocale + Default> Mul<Currency<L>> for isize {
25 type Output = Currency<L>;
26
27 fn mul(self, rhs: Currency<L>) -> Self::Output {
28 rhs * self
29 }
30}
31
32impl<L: CurrencyLocale + Default> Mul<isize> for Currency<L> {
33 type Output = Self;
34
35 fn mul(self, rhs: isize) -> Self::Output {
36 Self::new(
37 self.negative ^ rhs.is_negative(),
38 self.amount * rhs.unsigned_abs(),
39 self.locale,
40 )
41 }
42}
43
44impl<L: CurrencyLocale + Default> Mul<f32> for Currency<L> {
45 type Output = Self;
46
47 fn mul(self, rhs: f32) -> Self::Output {
48 Self::new(
49 self.negative ^ rhs.is_sign_negative(),
50 (self.amount * (rhs * 100.0).abs() as usize) / 100,
51 self.locale,
52 )
53 }
54}
55
56impl<L: CurrencyLocale + Default> Mul<Currency<L>> for f32 {
57 type Output = Currency<L>;
58
59 fn mul(self, rhs: Currency<L>) -> Self::Output {
60 rhs * self
61 }
62}
63
64impl<L: CurrencyLocale + Default> Mul<f64> for Currency<L> {
65 type Output = Self;
66
67 fn mul(self, rhs: f64) -> Self::Output {
68 Self::new(
69 self.negative ^ rhs.is_sign_negative(),
70 (self.amount * (rhs * 100.0).abs() as usize) / 100,
71 self.locale,
72 )
73 }
74}
75
76impl<L: CurrencyLocale + Default> Mul<Currency<L>> for f64 {
77 type Output = Currency<L>;
78
79 fn mul(self, rhs: Currency<L>) -> Self::Output {
80 rhs * self
81 }
82}
83
84#[cfg(test)]
85mod test {
86 use super::*;
87
88 #[derive(Clone, Copy, Default, Debug, PartialEq)]
89 enum CurrencyL {
90 #[default]
91 De,
92 }
93
94 impl CurrencyLocale for CurrencyL {
95 fn separator(&self) -> char {
96 ','
97 }
98
99 fn thousand_separator(&self) -> char {
100 '.'
101 }
102
103 fn currency_symbol(&self) -> &'static str {
104 "€"
105 }
106 }
107
108 #[test]
109 fn mul_usize() {
110 let curr = Currency::new(false, 2_22, CurrencyL::De);
111
112 let expected = curr * 2usize;
113 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
114 }
115
116 #[test]
117 fn mul_usize_rev() {
118 let curr = Currency::new(false, 2_22, CurrencyL::De);
119
120 let expected = 2usize * curr;
121 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
122 }
123
124 #[test]
125 fn mul_isize() {
126 let curr = Currency::new(false, 2_22, CurrencyL::De);
127
128 let expected = curr * 2isize;
129 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
130 }
131
132 #[test]
133 fn mul_isize_rev() {
134 let curr = Currency::new(false, 2_22, CurrencyL::De);
135
136 let expected = 2isize * curr;
137 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
138 }
139
140 #[test]
141 fn mul_isize_negative() {
142 let curr = Currency::new(false, 2_22, CurrencyL::De);
143
144 let expected = curr * -2isize;
145 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
146 }
147
148 #[test]
149 fn mul_isize_negative_rev() {
150 let curr = Currency::new(false, 2_22, CurrencyL::De);
151
152 let expected = -2isize * curr;
153 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
154 }
155
156 #[test]
157 fn mul_negative_isize_negative() {
158 let curr = Currency::new(true, 2_22, CurrencyL::De);
159
160 let expected = curr * -2isize;
161 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
162 }
163
164 #[test]
165 fn mul_negative_isize_negative_rev() {
166 let curr = Currency::new(true, 2_22, CurrencyL::De);
167
168 let expected = -2isize * curr;
169 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
170 }
171
172 #[test]
173 fn mul_f32() {
174 let curr = Currency::new(false, 2_22, CurrencyL::De);
175
176 let expected = curr * 2.0f32;
177 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
178 }
179
180 #[test]
181 fn mul_f32_rev() {
182 let curr = Currency::new(false, 2_22, CurrencyL::De);
183
184 let expected = 2.0f32 * curr;
185 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
186 }
187
188 #[test]
189 fn mul_f32_negative_currency() {
190 let curr = Currency::new(true, 2_22, CurrencyL::De);
191
192 let expected = 2.0f32 * curr;
193 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
194 }
195
196 #[test]
197 fn mul_negative_f32_negative_currency() {
198 let curr = Currency::new(true, 2_22, CurrencyL::De);
199
200 let expected = -2.0f32 * curr;
201 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
202 }
203
204 #[test]
205 fn mul_fraction_f32() {
206 let curr = Currency::new(false, 2_22, CurrencyL::De);
207
208 let expected = curr * 0.5f32;
209 assert_eq!(expected, Currency::new(false, 1_11, CurrencyL::De));
210 }
211
212 #[test]
213 fn mul_fraction_negative_f32() {
214 let curr = Currency::new(false, 2_22, CurrencyL::De);
215
216 let expected = curr * -0.5f32;
217 assert_eq!(expected, Currency::new(true, 1_11, CurrencyL::De));
218 }
219
220 #[test]
221 fn mul_fraction_f32_negative_currency() {
222 let curr = Currency::new(true, 2_22, CurrencyL::De);
223
224 let expected = curr * 0.5f32;
225 assert_eq!(expected, Currency::new(true, 1_11, CurrencyL::De));
226 }
227
228 #[test]
229 fn mul_negative_fraction_f32_negative_currency() {
230 let curr = Currency::new(true, 2_22, CurrencyL::De);
231
232 let expected = curr * -0.5f32;
233 assert_eq!(expected, Currency::new(false, 1_11, CurrencyL::De));
234 }
235
236 #[test]
237 fn mul_f64() {
238 let curr = Currency::new(false, 2_22, CurrencyL::De);
239
240 let expected = curr * 2.0f64;
241 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
242 }
243
244 #[test]
245 fn mul_negative_f64() {
246 let curr = Currency::new(false, 2_22, CurrencyL::De);
247
248 let expected = curr * -2.0f64;
249 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
250 }
251
252 #[test]
253 fn mul_f64_rev() {
254 let curr = Currency::new(false, 2_22, CurrencyL::De);
255
256 let expected = 2.0f64 * curr;
257 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
258 }
259
260 #[test]
261 fn mul_negative_f64_rev() {
262 let curr = Currency::new(false, 2_22, CurrencyL::De);
263
264 let expected = -2.0f64 * curr;
265 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
266 }
267
268 #[test]
269 fn mul_f64_negative_currency() {
270 let curr = Currency::new(true, 2_22, CurrencyL::De);
271
272 let expected = 2.0f64 * curr;
273 assert_eq!(expected, Currency::new(true, 4_44, CurrencyL::De));
274 }
275
276 #[test]
277 fn mul_negative_f64_negative_currency() {
278 let curr = Currency::new(true, 2_22, CurrencyL::De);
279
280 let expected = -2.0f64 * curr;
281 assert_eq!(expected, Currency::new(false, 4_44, CurrencyL::De));
282 }
283
284 #[test]
285 fn mul_fraction_f64() {
286 let curr = Currency::new(false, 2_22, CurrencyL::De);
287
288 let expected = curr * 0.5f64;
289 assert_eq!(expected, Currency::new(false, 1_11, CurrencyL::De));
290 }
291
292 #[test]
293 fn mul_fraction_negative_f64() {
294 let curr = Currency::new(false, 2_22, CurrencyL::De);
295
296 let expected = curr * -0.5f64;
297 assert_eq!(expected, Currency::new(true, 1_11, CurrencyL::De));
298 }
299
300 #[test]
301 fn mul_fraction_f64_negative_currency() {
302 let curr = Currency::new(true, 2_22, CurrencyL::De);
303
304 let expected = curr * 0.5f64;
305 assert_eq!(expected, Currency::new(true, 1_11, CurrencyL::De));
306 }
307
308 #[test]
309 fn mul_negative_fraction_f64_negative_currency() {
310 let curr = Currency::new(true, 2_22, CurrencyL::De);
311
312 let expected = curr * -0.5f64;
313 assert_eq!(expected, Currency::new(false, 1_11, CurrencyL::De));
314 }
315}