rbatis-codegen 4.9.4

The Rust SQL Toolkit and ORM Library. An async, pure Rust SQL crate featuring compile-time Dynamic SQL gen system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::ops::{AsProxy, BitShr};
use crate::ops_macros::{impl_numeric_binary_op, impl_same_type_shift_op, impl_value_binary_op};
use rbs::Value;

fn op_shr_value(left: Value, rhs: Value) -> Value {
    match left {
        Value::I32(s) => {
            let rhs = rhs.i64();
            if !(0..i32::BITS as i64).contains(&rhs) {
                return Value::I32(0);
            }
            Value::I32(s >> rhs)
        }
        Value::I64(s) => {
            let rhs = rhs.i64();
            if !(0..i64::BITS as i64).contains(&rhs) {
                return Value::I64(0);
            }
            Value::I64(s >> rhs)
        }
        Value::U32(s) => {
            let rhs = rhs.u64();
            if rhs >= u32::BITS as u64 {
                return Value::U32(0);
            }
            Value::U32(s >> rhs)
        }
        Value::U64(s) => {
            let rhs = rhs.u64();
            if rhs >= u64::BITS as u64 {
                return Value::U64(0);
            }
            Value::U64(s >> rhs)
        }
        Value::Ext(_, e) => op_shr_value(*e, rhs),
        _ => Value::Null,
    }
}

fn op_shr_u64(value: &Value, other: u64) -> u64 {
    if other >= u64::BITS as u64 {
        return 0;
    }
    value.u64() >> other
}

fn op_shr_i64(value: &Value, other: i64) -> i64 {
    if !(0..i64::BITS as i64).contains(&other) {
        return 0;
    }
    value.i64() >> other
}

fn op_shr_u64_value(value: &Value, other: u64) -> u64 {
    let rhs = value.u64();
    if rhs >= u64::BITS as u64 {
        return 0;
    }
    other >> rhs
}

fn op_shr_i64_value(value: &Value, other: i64) -> i64 {
    let rhs = value.i64();
    if !(0..i64::BITS as i64).contains(&rhs) {
        return 0;
    }
    other >> rhs
}

impl_value_binary_op!(BitShr, op_shr, op_shr_value);
impl_numeric_binary_op!(
    BitShr,
    op_shr,
    op_shr_u64,
    op_shr_u64_value,
    [u8, u16, u32, u64],
    u64
);
impl_numeric_binary_op!(
    BitShr,
    op_shr,
    op_shr_i64,
    op_shr_i64_value,
    [i8, i16, i32, i64, isize, usize],
    i64
);
impl_same_type_shift_op!(
    BitShr,
    op_shr,
    checked_shr,
    [u8, u16, u32, u64, i8, i16, i32, i64, isize, usize]
);

#[cfg(test)]
mod test {
    use crate::ops::BitShr;
    use rbs::Value;

    #[test]
    fn test_shr() {
        assert_eq!(Value::I32(8).op_shr(2i64), 2i64);
        assert_eq!((&Value::I32(8)).op_shr(&2i64), 2i64);
        assert_eq!(Value::I32(8).op_shr(&&Value::I32(2)), Value::I32(2));
        assert_eq!(8i64.op_shr(&Value::I32(2)), 2i64);
    }

    #[test]
    fn test_shr_out_of_range() {
        assert_eq!(Value::I32(8).op_shr(32i64), 0i64);
        assert_eq!(Value::I32(8).op_shr(&&Value::I32(32)), Value::I32(0));
    }
}