rtcm-rs 0.11.0

Encoding/decoding of RTCM v. 3
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
113
114
115
116
117
118
119
120
121
122

use core::{
    fmt::Debug,
    ops::{BitOrAssign, Shl, Shr},
};

pub trait BitValue
where
    Self::ValueType: Default
        + Copy
        + Debug
        + Shr<usize, Output = Self::ValueType>
        + Shl<usize, Output = Self::ValueType>
        + BitOrAssign<Self::ValueType>,
{
    //const BITS: usize;
    //const MAX: Self::ValueType;
    type ValueType;
    fn u8_cast(val: u8) -> Self::ValueType;
    fn val_cast(val: Self::ValueType) -> u8;
    fn sign_fix(val: Self::ValueType, len: usize) -> Self::ValueType;
    fn sign_fix_rev(val: Self::ValueType, len: usize) -> Self::ValueType;
}

macro_rules! u8_cast {
    () => {
        #[inline]
        fn u8_cast(val: u8) -> Self::ValueType {
            val as Self::ValueType
        }
    };
}
macro_rules! val_cast {
    () => {
        #[inline]
        fn val_cast(val: Self::ValueType) -> u8 {
            val as u8
        }
    };
}
macro_rules! impl_bit_value {
    ($mtype:ident, $ptype:ty, u) => {
        pub struct $mtype;
        impl BitValue for $mtype {
            //const BITS: usize = <$ptype>::BITS as usize;
            type ValueType = $ptype;
            u8_cast!();
            val_cast!();
            #[inline]
            fn sign_fix(val: Self::ValueType, _len: usize) -> Self::ValueType {
                val
            }
            #[inline]
            fn sign_fix_rev(val: Self::ValueType, _len: usize) -> Self::ValueType {
                val
            }
        }
    };
    ($mtype:ident, $ptype:ty, s) => {
        pub struct $mtype;
        impl BitValue for $mtype {
            //const BITS: usize = <$ptype>::BITS as usize;
            type ValueType = $ptype;
            u8_cast!();
            val_cast!();
            #[inline]
            fn sign_fix(val: Self::ValueType, len: usize) -> Self::ValueType {
                if val & (1 << (len - 1)) == 0 || len == <$ptype>::BITS as usize {
                    val
                } else {
                    val | (-1 << len)
                }
            }
            #[inline]
            fn sign_fix_rev(val: Self::ValueType, _len: usize) -> Self::ValueType {
                val
            }
        }
    };
    ($mtype:ident, $ptype:ty, sm) => {
        pub struct $mtype;
        impl BitValue for $mtype {
            //const BITS: usize = <$ptype>::BITS as usize;
            type ValueType = $ptype;
            u8_cast!();
            val_cast!();
            #[inline]
            fn sign_fix(val: Self::ValueType, len: usize) -> Self::ValueType {
                if val & (1 << (len - 1)) == 0 {
                    val
                } else {
                    //println!("shift={}", (Self::BITS - len + 1));
                    //println!("valshift={}", (-1 >> (Self::BITS - len + 1)));
                    -1 * (val & (!(-1 << (len - 1))))
                }
            }
            #[inline]
            fn sign_fix_rev(val: Self::ValueType, len: usize) -> Self::ValueType {
                if val & (1 << (len - 1)) == 0 {
                    val
                } else {
                    ((!val) + 1) | (1 << (len - 1))
                }
            }
        }
    };
}

impl_bit_value!(U8, u8, u);
impl_bit_value!(U16, u16, u);
impl_bit_value!(U32, u32, u);
impl_bit_value!(U64, u64, u);
impl_bit_value!(U128, u128, u);
impl_bit_value!(I8, i8, s);
impl_bit_value!(I16, i16, s);
impl_bit_value!(I32, i32, s);
impl_bit_value!(I64, i64, s);
impl_bit_value!(I128, i128, s);
impl_bit_value!(SM8, i8, sm);
impl_bit_value!(SM16, i16, sm);
impl_bit_value!(SM32, i32, sm);
impl_bit_value!(SM64, i64, sm);
impl_bit_value!(SM128, i128, sm);