Grcov report - cmp.rs

1

use crate::{Denominator, Numerator, Q};

2

use core::cmp;

3

use core::ops::Mul;

4

use typenum::{Compare, Equal, Greater, Less, Ord, Prod};

5

6

mod private {

7

    use super::*;

8

9

    pub trait Sealed {

10

        const INSTANCE: Self;

11

12

13

    impl Sealed for Equal {

14

        const INSTANCE: Self = Equal;

15

16

17

    impl Sealed for Greater {

18

        const INSTANCE: Self = Greater;

19

20

21

    impl Sealed for Less {

22

        const INSTANCE: Self = Less;

23

24

25

    pub trait PrivateCmpHelper<Rhs = Self> {

26

        type Output: Ordering;

27

28

29

    impl<Nl, Dl, Nr, Dr> PrivateCmpHelper<Q<Nr, Dr>> for Q<Nl, Dl>

30

    where

31

        Nl: Numerator<Dl> + Mul<Dr>,

32

        Dl: Denominator,

33

        Nr: Numerator<Dr> + Mul<Dl>,

34

        Dr: Denominator,

35

        Prod<Nl, Dr>: typenum::Cmp<Prod<Nr, Dl>>,

36

        Compare<Prod<Nl, Dr>, Prod<Nr, Dl>>: Ordering,

37

38

        type Output = Compare<Prod<Nl, Dr>, Prod<Nr, Dl>>;

39

40

41

42

/// Type-level orderings.

43

pub trait Ordering: Ord + private::Sealed {}

44

45

impl Ordering for Equal {}

46

47

impl Ordering for Greater {}

48

49

impl Ordering for Less {}

50

51

/// Type-level comparison.

52

pub trait Cmp<Rhs = Self> {

53

    /// The resulting type after type-level comparison.

54

    type Output: Ordering;

55

56

    /// Performs comparison.

57

3

    fn cmp(&self, other: &Rhs) -> Self::Output {

58

3

        let _ = other;

59

3

        <Self::Output as private::Sealed>::INSTANCE

60

3

61

62

63

impl<Nl, Dl, Nr, Dr> Cmp<Q<Nr, Dr>> for Q<Nl, Dl>

64

where

65

    Self: private::PrivateCmpHelper<Q<Nr, Dr>>,

66

    Nl: Numerator<Dl>,

67

    Dl: Denominator,

68

    Nr: Numerator<Dr>,

69

    Dr: Denominator,

70

71

    type Output = <Self as private::PrivateCmpHelper<Q<Nr, Dr>>>::Output;

72

73

74

impl<Nl, Dl, Nr, Dr> PartialEq<Q<Nr, Dr>> for Q<Nl, Dl>

75

where

76

    Self: Cmp<Q<Nr, Dr>>,

77

    Nl: Numerator<Dl>,

78

    Dl: Denominator,

79

    Nr: Numerator<Dr>,

80

    Dr: Denominator,

81

82

41

    fn eq(&self, other: &Q<Nr, Dr>) -> bool {

83

41

        let _ = other;

84

41

        <Self as Cmp<Q<Nr, Dr>>>::Output::to_ordering() == cmp::Ordering::Equal

85

41

86

87

88

impl<Nl, Dl, Nr, Dr> PartialOrd<Q<Nr, Dr>> for Q<Nl, Dl>

89

where

90

    Self: Cmp<Q<Nr, Dr>>,

91

    Nl: Numerator<Dl>,

92

    Dl: Denominator,

93

    Nr: Numerator<Dr>,

94

    Dr: Denominator,

95

96

4

    fn partial_cmp(&self, other: &Q<Nr, Dr>) -> Option<cmp::Ordering> {

97

4

        let _ = other;

98

4

        Some(<Self as Cmp<Q<Nr, Dr>>>::Output::to_ordering())

99

4

100

101

102

#[cfg(test)]

103

mod tests {

104

    use super::*;

105

    use typenum::consts::*;

106

107

    #[test]

108

1

    fn test_cmp() {

109

1

        assert_eq!(Q::<P1, P2>::new().cmp(&Q::<P1, P3>::new()), Greater);

110

1

        assert_eq!(Q::<N1, P2>::new().cmp(&Q::<P1, P3>::new()), Less);

111

1

        assert_eq!(Q::<N1, P2>::new().cmp(&Q::<N1, P2>::new()), Equal);

112

1

113

114

    #[test]

115

1

    fn test_eq() {

116

1

        assert!(Q::<P1, P2>::new() != Q::<P1, P3>::new());

117

1

        assert!(Q::<N1, P2>::new() != Q::<P1, P3>::new());

118

1

        assert!(Q::<N1, P2>::new() == Q::<N1, P2>::new());

119

1

120

121

    #[test]

122

1

    fn test_ord() {

123

1

        assert!(Q::<P1, P2>::new() > Q::<P1, P3>::new());

124

1

        assert!(Q::<N1, P2>::new() < Q::<P1, P3>::new());

125

1

        assert!(Q::<N1, P2>::new() >= Q::<N1, P2>::new());

126

1

        assert!(Q::<N1, P2>::new() <= Q::<N1, P2>::new());

127

1

128