typenum/
private.rs

Help
1//! **Ignore me!** This module is for things that are conceptually private but that must
2//! be made public for typenum to work correctly.
3//!
4//! Unless you are working on typenum itself, **there is no need to view anything here**.
5//!
6//! Certainly don't implement any of the traits here for anything.
7//!
8//!
9//! Just look away.
10//!
11//!
12//! Loooooooooooooooooooooooooooooooooook awaaaaaaaaaaaayyyyyyyyyyyyyyyyyyyyyyyyyyyyy...
13//!
14//!
15//! If you do manage to find something of use in here, please let me know. If you can make a
16//! compelling case, it may be moved out of __private.
17//!
18//! Note: Aliases for private type operators will all be named simply that operator followed
19//! by an abbreviated name of its associated type.
20
21#![doc(hidden)]
22
23use crate::{
24    bit::{Bit, B0, B1},
25    uint::{UInt, UTerm, Unsigned},
26};
27
28/// A marker for restricting a method on a public trait to internal use only.
29pub(crate) enum Internal {}
30
31pub trait InternalMarker {}
32
33impl InternalMarker for Internal {}
34
35/// Convenience trait. Calls `Invert` -> `TrimTrailingZeros` -> `Invert`
36pub trait Trim {
37    type Output;
38
39    fn trim(self) -> Self::Output;
40}
41pub type TrimOut<A> = <A as Trim>::Output;
42
43/// Gets rid of all zeros until it hits a one.
44// ONLY IMPLEMENT FOR INVERTED NUMBERS!
45pub trait TrimTrailingZeros {
46    type Output;
47
48    fn trim_trailing_zeros(self) -> Self::Output;
49}
50pub type TrimTrailingZerosOut<A> = <A as TrimTrailingZeros>::Output;
51
52/// Converts between standard numbers and inverted ones that have the most significant
53/// digit on the outside.
54pub trait Invert {
55    type Output;
56
57    fn invert(self) -> Self::Output;
58}
59pub type InvertOut<A> = <A as Invert>::Output;
60
61/// Doubly private! Called by invert to make the magic happen once its done the first step.
62/// The Rhs is what we've got so far.
63pub trait PrivateInvert<Rhs> {
64    type Output;
65
66    fn private_invert(self, rhs: Rhs) -> Self::Output;
67}
68pub type PrivateInvertOut<A, Rhs> = <A as PrivateInvert<Rhs>>::Output;
69
70/// Terminating character for `InvertedUInt`s
71pub struct InvertedUTerm;
72
73/// Inverted `UInt` (has most significant digit on the outside)
74pub struct InvertedUInt<IU: InvertedUnsigned, B: Bit> {
75    msb: IU,
76    lsb: B,
77}
78
79/// Does the real anding for `UInt`s; `And` just calls this and then `Trim`.
80pub trait PrivateAnd<Rhs = Self> {
81    type Output;
82
83    fn private_and(self, rhs: Rhs) -> Self::Output;
84}
85pub type PrivateAndOut<A, Rhs> = <A as PrivateAnd<Rhs>>::Output;
86
87/// Does the real xoring for `UInt`s; `Xor` just calls this and then `Trim`.
88pub trait PrivateXor<Rhs = Self> {
89    type Output;
90
91    fn private_xor(self, rhs: Rhs) -> Self::Output;
92}
93pub type PrivateXorOut<A, Rhs> = <A as PrivateXor<Rhs>>::Output;
94
95/// Does the real subtraction for `UInt`s; `Sub` just calls this and then `Trim`.
96pub trait PrivateSub<Rhs = Self> {
97    type Output;
98
99    fn private_sub(self, rhs: Rhs) -> Self::Output;
100}
101pub type PrivateSubOut<A, Rhs> = <A as PrivateSub<Rhs>>::Output;
102
103/// Used for addition of signed integers; `C = P.cmp(N)`
104/// Assumes `P = Self` is positive and `N` is negative
105/// where `P` and `N` are both passed as unsigned integers
106pub trait PrivateIntegerAdd<C, N> {
107    type Output;
108
109    fn private_integer_add(self, _: C, _: N) -> Self::Output;
110}
111pub type PrivateIntegerAddOut<P, C, N> = <P as PrivateIntegerAdd<C, N>>::Output;
112
113pub trait PrivatePow<Y, N> {
114    type Output;
115
116    fn private_pow(self, _: Y, _: N) -> Self::Output;
117}
118pub type PrivatePowOut<A, Y, N> = <A as PrivatePow<Y, N>>::Output;
119
120/// Performs `Shl` on `Lhs` so that `SizeOf(Lhs) = SizeOf(Rhs)`
121/// Fails if `SizeOf(Lhs) > SizeOf(Rhs)`
122pub trait ShiftDiff<Rhs> {
123    type Output;
124}
125pub type ShiftDiffOut<A, Rhs> = <A as ShiftDiff<Rhs>>::Output;
126
127/// Gives `SizeOf(Lhs) - SizeOf(Rhs)`
128pub trait BitDiff<Rhs> {
129    type Output;
130}
131pub type BitDiffOut<A, Rhs> = <A as BitDiff<Rhs>>::Output;
132
133/// Inverted unsigned numbers
134pub trait InvertedUnsigned {
135    fn to_u64() -> u64;
136}
137
138impl InvertedUnsigned for InvertedUTerm {
139    #[inline]
140    fn to_u64() -> u64 {
141        0
142    }
143}
144
145impl<IU: InvertedUnsigned, B: Bit> InvertedUnsigned for InvertedUInt<IU, B> {
146    #[inline]
147    fn to_u64() -> u64 {
148        u64::from(B::to_u8()) | IU::to_u64() << 1
149    }
150}
151
152impl Invert for UTerm {
153    type Output = InvertedUTerm;
154
155    #[inline]
156    fn invert(self) -> Self::Output {
157        InvertedUTerm
158    }
159}
160
161impl<U: Unsigned, B: Bit> Invert for UInt<U, B>
162where
163    U: PrivateInvert<InvertedUInt<InvertedUTerm, B>>,
164{
165    type Output = PrivateInvertOut<U, InvertedUInt<InvertedUTerm, B>>;
166
167    #[inline]
168    fn invert(self) -> Self::Output {
169        self.msb.private_invert(InvertedUInt {
170            msb: InvertedUTerm,
171            lsb: self.lsb,
172        })
173    }
174}
175
176impl<IU: InvertedUnsigned> PrivateInvert<IU> for UTerm {
177    type Output = IU;
178
179    #[inline]
180    fn private_invert(self, rhs: IU) -> Self::Output {
181        rhs
182    }
183}
184
185impl<IU: InvertedUnsigned, U: Unsigned, B: Bit> PrivateInvert<IU> for UInt<U, B>
186where
187    U: PrivateInvert<InvertedUInt<IU, B>>,
188{
189    type Output = PrivateInvertOut<U, InvertedUInt<IU, B>>;
190
191    #[inline]
192    fn private_invert(self, rhs: IU) -> Self::Output {
193        self.msb.private_invert(InvertedUInt {
194            msb: rhs,
195            lsb: self.lsb,
196        })
197    }
198}
199
200#[test]
201fn test_inversion() {
202    type Test4 = <crate::consts::U4 as Invert>::Output;
203    type Test5 = <crate::consts::U5 as Invert>::Output;
204    type Test12 = <crate::consts::U12 as Invert>::Output;
205    type Test16 = <crate::consts::U16 as Invert>::Output;
206
207    assert_eq!(1, <Test4 as InvertedUnsigned>::to_u64());
208    assert_eq!(5, <Test5 as InvertedUnsigned>::to_u64());
209    assert_eq!(3, <Test12 as InvertedUnsigned>::to_u64());
210    assert_eq!(1, <Test16 as InvertedUnsigned>::to_u64());
211}
212
213impl Invert for InvertedUTerm {
214    type Output = UTerm;
215
216    #[inline]
217    fn invert(self) -> Self::Output {
218        UTerm
219    }
220}
221
222impl<IU: InvertedUnsigned, B: Bit> Invert for InvertedUInt<IU, B>
223where
224    IU: PrivateInvert<UInt<UTerm, B>>,
225{
226    type Output = <IU as PrivateInvert<UInt<UTerm, B>>>::Output;
227
228    #[inline]
229    fn invert(self) -> Self::Output {
230        self.msb.private_invert(UInt {
231            msb: UTerm,
232            lsb: self.lsb,
233        })
234    }
235}
236
237impl<U: Unsigned> PrivateInvert<U> for InvertedUTerm {
238    type Output = U;
239
240    #[inline]
241    fn private_invert(self, rhs: U) -> Self::Output {
242        rhs
243    }
244}
245
246impl<U: Unsigned, IU: InvertedUnsigned, B: Bit> PrivateInvert<U> for InvertedUInt<IU, B>
247where
248    IU: PrivateInvert<UInt<U, B>>,
249{
250    type Output = <IU as PrivateInvert<UInt<U, B>>>::Output;
251
252    #[inline]
253    fn private_invert(self, rhs: U) -> Self::Output {
254        self.msb.private_invert(UInt {
255            msb: rhs,
256            lsb: self.lsb,
257        })
258    }
259}
260
261#[test]
262fn test_double_inversion() {
263    type Test4 = <<crate::consts::U4 as Invert>::Output as Invert>::Output;
264    type Test5 = <<crate::consts::U5 as Invert>::Output as Invert>::Output;
265    type Test12 = <<crate::consts::U12 as Invert>::Output as Invert>::Output;
266    type Test16 = <<crate::consts::U16 as Invert>::Output as Invert>::Output;
267
268    assert_eq!(4, <Test4 as Unsigned>::to_u64());
269    assert_eq!(5, <Test5 as Unsigned>::to_u64());
270    assert_eq!(12, <Test12 as Unsigned>::to_u64());
271    assert_eq!(16, <Test16 as Unsigned>::to_u64());
272}
273
274impl TrimTrailingZeros for InvertedUTerm {
275    type Output = InvertedUTerm;
276
277    #[inline]
278    fn trim_trailing_zeros(self) -> Self::Output {
279        InvertedUTerm
280    }
281}
282
283impl<IU: InvertedUnsigned> TrimTrailingZeros for InvertedUInt<IU, B1> {
284    type Output = Self;
285
286    #[inline]
287    fn trim_trailing_zeros(self) -> Self::Output {
288        self
289    }
290}
291
292impl<IU: InvertedUnsigned> TrimTrailingZeros for InvertedUInt<IU, B0>
293where
294    IU: TrimTrailingZeros,
295{
296    type Output = <IU as TrimTrailingZeros>::Output;
297
298    #[inline]
299    fn trim_trailing_zeros(self) -> Self::Output {
300        self.msb.trim_trailing_zeros()
301    }
302}
303
304impl<U: Unsigned> Trim for U
305where
306    U: Invert,
307    <U as Invert>::Output: TrimTrailingZeros,
308    <<U as Invert>::Output as TrimTrailingZeros>::Output: Invert,
309{
310    type Output = <<<U as Invert>::Output as TrimTrailingZeros>::Output as Invert>::Output;
311
312    #[inline]
313    fn trim(self) -> Self::Output {
314        self.invert().trim_trailing_zeros().invert()
315    }
316}
317
318// Note: Trimming is tested when we do subtraction.
319
320pub trait PrivateCmp<Rhs, SoFar> {
321    type Output;
322
323    fn private_cmp(&self, _: &Rhs, _: SoFar) -> Self::Output;
324}
325pub type PrivateCmpOut<A, Rhs, SoFar> = <A as PrivateCmp<Rhs, SoFar>>::Output;
326
327// Set Bit
328pub trait PrivateSetBit<I, B> {
329    type Output;
330
331    fn private_set_bit(self, _: I, _: B) -> Self::Output;
332}
333pub type PrivateSetBitOut<N, I, B> = <N as PrivateSetBit<I, B>>::Output;
334
335// Div
336pub trait PrivateDiv<N, D, Q, R, I> {
337    type Quotient;
338    type Remainder;
339
340    fn private_div_quotient(self, _: N, _: D, _: Q, _: R, _: I) -> Self::Quotient;
341
342    fn private_div_remainder(self, _: N, _: D, _: Q, _: R, _: I) -> Self::Remainder;
343}
344
345pub type PrivateDivQuot<N, D, Q, R, I> = <() as PrivateDiv<N, D, Q, R, I>>::Quotient;
346pub type PrivateDivRem<N, D, Q, R, I> = <() as PrivateDiv<N, D, Q, R, I>>::Remainder;
347
348pub trait PrivateDivIf<N, D, Q, R, I, RcmpD> {
349    type Quotient;
350    type Remainder;
351
352    fn private_div_if_quotient(self, _: N, _: D, _: Q, _: R, _: I, _: RcmpD) -> Self::Quotient;
353
354    fn private_div_if_remainder(self, _: N, _: D, _: Q, _: R, _: I, _: RcmpD) -> Self::Remainder;
355}
356
357pub type PrivateDivIfQuot<N, D, Q, R, I, RcmpD> =
358    <() as PrivateDivIf<N, D, Q, R, I, RcmpD>>::Quotient;
359pub type PrivateDivIfRem<N, D, Q, R, I, RcmpD> =
360    <() as PrivateDivIf<N, D, Q, R, I, RcmpD>>::Remainder;
361
362// Div for signed ints
363pub trait PrivateDivInt<C, Divisor> {
364    type Output;
365
366    fn private_div_int(self, _: C, _: Divisor) -> Self::Output;
367}
368pub type PrivateDivIntOut<A, C, Divisor> = <A as PrivateDivInt<C, Divisor>>::Output;
369
370pub trait PrivateRem<URem, Divisor> {
371    type Output;
372
373    fn private_rem(self, _: URem, _: Divisor) -> Self::Output;
374}
375pub type PrivateRemOut<A, URem, Divisor> = <A as PrivateRem<URem, Divisor>>::Output;
376
377// min max
378pub trait PrivateMin<Rhs, CmpResult> {
379    type Output;
380    fn private_min(self, rhs: Rhs) -> Self::Output;
381}
382pub type PrivateMinOut<A, B, CmpResult> = <A as PrivateMin<B, CmpResult>>::Output;
383
384pub trait PrivateMax<Rhs, CmpResult> {
385    type Output;
386    fn private_max(self, rhs: Rhs) -> Self::Output;
387}
388pub type PrivateMaxOut<A, B, CmpResult> = <A as PrivateMax<B, CmpResult>>::Output;
389
390// Comparisons
391
392use crate::{Equal, False, Greater, Less, True};
393
394pub trait IsLessPrivate<Rhs, Cmp> {
395    type Output: Bit;
396
397    #[allow(clippy::wrong_self_convention)]
398    fn is_less_private(self, _: Rhs, _: Cmp) -> Self::Output;
399}
400
401impl<A, B> IsLessPrivate<B, Less> for A {
402    type Output = True;
403
404    #[inline]
405    fn is_less_private(self, _: B, _: Less) -> Self::Output {
406        B1
407    }
408}
409impl<A, B> IsLessPrivate<B, Equal> for A {
410    type Output = False;
411
412    #[inline]
413    fn is_less_private(self, _: B, _: Equal) -> Self::Output {
414        B0
415    }
416}
417impl<A, B> IsLessPrivate<B, Greater> for A {
418    type Output = False;
419
420    #[inline]
421    fn is_less_private(self, _: B, _: Greater) -> Self::Output {
422        B0
423    }
424}
425
426pub trait IsEqualPrivate<Rhs, Cmp> {
427    type Output: Bit;
428
429    #[allow(clippy::wrong_self_convention)]
430    fn is_equal_private(self, _: Rhs, _: Cmp) -> Self::Output;
431}
432
433impl<A, B> IsEqualPrivate<B, Less> for A {
434    type Output = False;
435
436    #[inline]
437    fn is_equal_private(self, _: B, _: Less) -> Self::Output {
438        B0
439    }
440}
441impl<A, B> IsEqualPrivate<B, Equal> for A {
442    type Output = True;
443
444    #[inline]
445    fn is_equal_private(self, _: B, _: Equal) -> Self::Output {
446        B1
447    }
448}
449impl<A, B> IsEqualPrivate<B, Greater> for A {
450    type Output = False;
451
452    #[inline]
453    fn is_equal_private(self, _: B, _: Greater) -> Self::Output {
454        B0
455    }
456}
457
458pub trait IsGreaterPrivate<Rhs, Cmp> {
459    type Output: Bit;
460
461    #[allow(clippy::wrong_self_convention)]
462    fn is_greater_private(self, _: Rhs, _: Cmp) -> Self::Output;
463}
464
465impl<A, B> IsGreaterPrivate<B, Less> for A {
466    type Output = False;
467
468    #[inline]
469    fn is_greater_private(self, _: B, _: Less) -> Self::Output {
470        B0
471    }
472}
473impl<A, B> IsGreaterPrivate<B, Equal> for A {
474    type Output = False;
475
476    #[inline]
477    fn is_greater_private(self, _: B, _: Equal) -> Self::Output {
478        B0
479    }
480}
481impl<A, B> IsGreaterPrivate<B, Greater> for A {
482    type Output = True;
483
484    #[inline]
485    fn is_greater_private(self, _: B, _: Greater) -> Self::Output {
486        B1
487    }
488}
489
490pub trait IsLessOrEqualPrivate<Rhs, Cmp> {
491    type Output: Bit;
492
493    #[allow(clippy::wrong_self_convention)]
494    fn is_less_or_equal_private(self, _: Rhs, _: Cmp) -> Self::Output;
495}
496
497impl<A, B> IsLessOrEqualPrivate<B, Less> for A {
498    type Output = True;
499
500    #[inline]
501    fn is_less_or_equal_private(self, _: B, _: Less) -> Self::Output {
502        B1
503    }
504}
505impl<A, B> IsLessOrEqualPrivate<B, Equal> for A {
506    type Output = True;
507
508    #[inline]
509    fn is_less_or_equal_private(self, _: B, _: Equal) -> Self::Output {
510        B1
511    }
512}
513impl<A, B> IsLessOrEqualPrivate<B, Greater> for A {
514    type Output = False;
515
516    #[inline]
517    fn is_less_or_equal_private(self, _: B, _: Greater) -> Self::Output {
518        B0
519    }
520}
521
522pub trait IsNotEqualPrivate<Rhs, Cmp> {
523    type Output: Bit;
524
525    #[allow(clippy::wrong_self_convention)]
526    fn is_not_equal_private(self, _: Rhs, _: Cmp) -> Self::Output;
527}
528
529impl<A, B> IsNotEqualPrivate<B, Less> for A {
530    type Output = True;
531
532    #[inline]
533    fn is_not_equal_private(self, _: B, _: Less) -> Self::Output {
534        B1
535    }
536}
537impl<A, B> IsNotEqualPrivate<B, Equal> for A {
538    type Output = False;
539
540    #[inline]
541    fn is_not_equal_private(self, _: B, _: Equal) -> Self::Output {
542        B0
543    }
544}
545impl<A, B> IsNotEqualPrivate<B, Greater> for A {
546    type Output = True;
547
548    #[inline]
549    fn is_not_equal_private(self, _: B, _: Greater) -> Self::Output {
550        B1
551    }
552}
553
554pub trait IsGreaterOrEqualPrivate<Rhs, Cmp> {
555    type Output: Bit;
556
557    #[allow(clippy::wrong_self_convention)]
558    fn is_greater_or_equal_private(self, _: Rhs, _: Cmp) -> Self::Output;
559}
560
561impl<A, B> IsGreaterOrEqualPrivate<B, Less> for A {
562    type Output = False;
563
564    #[inline]
565    fn is_greater_or_equal_private(self, _: B, _: Less) -> Self::Output {
566        B0
567    }
568}
569impl<A, B> IsGreaterOrEqualPrivate<B, Equal> for A {
570    type Output = True;
571
572    #[inline]
573    fn is_greater_or_equal_private(self, _: B, _: Equal) -> Self::Output {
574        B1
575    }
576}
577impl<A, B> IsGreaterOrEqualPrivate<B, Greater> for A {
578    type Output = True;
579
580    #[inline]
581    fn is_greater_or_equal_private(self, _: B, _: Greater) -> Self::Output {
582        B1
583    }
584}
585
586pub trait PrivateSquareRoot {
587    type Output;
588}
589
590pub trait PrivateLogarithm2 {
591    type Output;
592}
typenum/private.rs

typenum/
private.rs
