rtcm_rs/msg/
mod.rs

1use tinyvec::ArrayVec;
2
3pub mod message;
4
5mod msm_mappings;
6
7pub use msm_mappings::bds::SigId as BdsSigId;
8pub use msm_mappings::gal::SigId as GalSigId;
9pub use msm_mappings::glo::SigId as GloSigId;
10pub use msm_mappings::gps::SigId as GpsSigId;
11pub use msm_mappings::navic::SigId as NavicSigId;
12pub use msm_mappings::qzss::SigId as QzssSigId;
13pub use msm_mappings::sbas::SigId as SbasSigId;
14
15macro_rules! msg {
16    (
17        id: $id:ident,
18        type_name: $type_name:ident,
19        fields: [ $( ( $field_name:ident, $frag_id:ident $(, $len_data:tt )? ) ),+ ],
20    ) => {
21        pub mod $id {
22            use $crate::df::{assembler::Assembler, parser::Parser};
23            use $crate::df::dfs::*;
24            use $crate::rtcm_error::RtcmError;
25            #[cfg(feature = "serde")]
26            use $crate::{Serialize,Deserialize};
27            #[cfg(feature = "test_gen")]
28            use $crate::source_repr::SourceRepr;
29            #[allow(unused)]
30            use super::*; //Do not remove
31
32            pub mod export_types {
33                $(
34                    #[allow(unused)]
35                    pub use super::$frag_id::export_types::*;
36                )+
37
38                pub use super::$type_name;
39            }
40
41            #[derive(Default, Clone, Debug, PartialEq)]
42            #[cfg_attr(feature="serde",derive(Serialize,Deserialize),serde(crate = "sd"))]
43            pub struct $type_name {
44                $(pub $field_name:$frag_id::DataType),+
45            }
46            pub type DataType = $type_name;
47            pub fn encode(asm:&mut Assembler, value:&$type_name) -> Result<(),RtcmError> {
48                $(
49                    $frag_id::encode(asm, &value.$field_name)?;
50                )+
51                Ok(())
52            }
53            pub fn decode(par:&mut Parser) -> Result<$type_name,RtcmError> {
54                $(
55                    #[allow(unused)]
56                    let $field_name = $frag_id::decode(par, $($len_data)? )?;
57                )+
58
59                Ok($type_name {
60                    $(
61                        $field_name
62                    ),+
63                })
64            }
65            #[cfg(feature = "test_gen")]
66            use $crate::val_gen::ValGen;
67            #[cfg(feature = "test_gen")]
68            pub fn generate<FR,LR,RR>(asm:&mut Assembler, val_gen:&mut ValGen<FR,LR,RR>) -> Result<(),RtcmError>
69                where FR:rand::Rng, LR:rand::Rng, RR:rand::Rng {
70
71                $(
72                    #[allow(unused)]
73                    let $field_name = $frag_id::generate(asm, val_gen, $($len_data)? )?;
74                )+
75                Ok(())
76            }
77            #[cfg(feature = "test_gen")]
78            impl SourceRepr for $type_name {
79                fn to_source(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
80                    use core::fmt::Write;
81                    write!(f, "{} {{", stringify!($type_name))?;
82                    $(
83                        write!(f,"{}:", stringify!($field_name))?;
84                        self.$field_name.to_source(f)?;
85                        f.write_char(',')?;
86                    )+
87                    f.write_char('}')
88                }
89            }
90        }
91    };
92}
93#[allow(unused)]
94macro_rules! msg_len_middle {
95    (
96        id: $id:ident,
97        type_name: $type_name:ident,
98        fields1: [ $( ( $field_name1:ident, $frag_id1:ident ) ),+ ],
99        len_field: $len_df_id:ident,
100        fields2: [ $( ( $field_name2:ident, $frag_id2:ident ) ),+ ],
101        vec_field: $vec_field_name:ident, $vec_frag_id:ident,
102    ) => {
103        pub mod $id {
104            use $crate::df::{assembler::Assembler, parser::Parser};
105            use $crate::df::dfs::*;
106            use $crate::rtcm_error::RtcmError;
107            #[cfg(feature = "serde")]
108            use $crate::{Serialize,Deserialize};
109            #[cfg(feature = "test_gen")]
110            use $crate::source_repr::SourceRepr;
111            #[allow(unused)]
112            use super::*; //Do not remove
113
114            pub mod export_types {
115                $(
116                    #[allow(unused)]
117                    pub use super::$frag_id1::export_types::*;
118                )+
119                $(
120                    #[allow(unused)]
121                    pub use super::$frag_id2::export_types::*;
122                )+
123                #[allow(unused)]
124                pub use super::$len_df_id::export_types::*;
125                pub use super::$vec_frag_id::export_types::*;
126
127                pub use super::$type_name;
128            }
129
130            #[derive(Default, Clone, Debug, PartialEq)]
131            #[cfg_attr(feature="serde",derive(Serialize,Deserialize),serde(crate = "sd"))]
132            pub struct $type_name {
133                $(pub $field_name1:$frag_id1::DataType,)+
134                $(pub $field_name2:$frag_id2::DataType,)+
135                pub $vec_field_name:$vec_frag_id::DataType,
136            }
137            pub type DataType = $type_name;
138            pub fn encode(asm:&mut Assembler, value:&$type_name) -> Result<(),RtcmError> {
139                //encode fields1
140                $(
141                    $frag_id1::encode(asm, &value.$field_name1)?;
142                )+
143                //encode len field
144                $len_df_id::encode(asm, &value.$vec_field_name.len())?;
145                //encode fields2
146                $(
147                    $frag_id2::encode(asm, &value.$field_name2)?;
148                )+
149                //encode vec field
150                $vec_frag_id::encode(asm, &value.$vec_field_name)?;
151
152                Ok(())
153            }
154            pub fn decode(par:&mut Parser) -> Result<$type_name,RtcmError> {
155                $(
156                    #[allow(unused)]
157                    let $field_name1 = $frag_id1::decode(par)?;
158                )+
159                let vec_len:usize = $len_df_id::decode(par)?;
160                $(
161                    #[allow(unused)]
162                    let $field_name2 = $frag_id2::decode(par)?;
163                )+
164                let $vec_field_name = $vec_frag_id::decode(par, vec_len)?;
165
166                Ok($type_name {
167                    $(
168                        $field_name1,
169                    )+
170                    $(
171                        $field_name2,
172                    )+
173                    $vec_field_name,
174                })
175            }
176            #[cfg(feature = "test_gen")]
177            use $crate::val_gen::ValGen;
178            #[cfg(feature = "test_gen")]
179            pub fn generate<FR,LR,RR>(asm:&mut Assembler, val_gen:&mut ValGen<FR,LR,RR>) -> Result<(),RtcmError>
180                where FR:rand::Rng, LR:rand::Rng, RR:rand::Rng {
181
182                $(
183                    #[allow(unused)]
184                    let _ = $frag_id1::generate(asm, val_gen)?;
185                )+
186                let vec_len = $len_df_id::generate(asm, val_gen)?;
187                $(
188                    #[allow(unused)]
189                    let _ = $frag_id2::generate(asm, val_gen)?;
190                )+
191                let _ = $vec_frag_id::generate(asm, val_gen, vec_len)?;
192                Ok(())
193            }
194            #[cfg(feature = "test_gen")]
195            impl SourceRepr for $type_name {
196                fn to_source(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
197                    use core::fmt::Write;
198                    write!(f, "{} {{", stringify!($type_name))?;
199                    $(
200                        write!(f,"{}:", stringify!($field_name1))?;
201                        self.$field_name1.to_source(f)?;
202                        f.write_char(',')?;
203                    )+
204                    $(
205                        write!(f,"{}:", stringify!($field_name2))?;
206                        self.$field_name2.to_source(f)?;
207                        f.write_char(',')?;
208                    )+
209                    write!(f,"{}:", stringify!($vec_field_name))?;
210                    self.$vec_field_name.to_source(f)?;
211
212                    f.write_char('}')
213                }
214            }
215        }
216    };
217}
218#[allow(unused)]
219macro_rules! frag_vec {
220    (
221        id: $id:ident,
222        frag_id: $frag_id:ident,
223        cap_name: $cap_name:ident,
224    ) => {
225        pub mod $id {
226            use super::*;
227            use $crate::df::{assembler::Assembler, parser::Parser};
228            use $crate::msg::*;
229            use $crate::rtcm_error::RtcmError;
230            use $crate::util::DataVec;
231
232            pub mod export_types {
233                #[allow(unused)]
234                pub use super::$frag_id::export_types::*;
235            }
236
237            pub type DataType = DataVec<$frag_id::DataType, $cap_name>;
238            pub fn encode(asm: &mut Assembler, value: &DataType) -> Result<(), RtcmError> {
239                for v in value.iter() {
240                    $frag_id::encode(asm, v)?;
241                }
242                Ok(())
243            }
244            pub fn decode(par: &mut Parser, len: usize) -> Result<DataType, RtcmError> {
245                if len > $cap_name {
246                    return Err(RtcmError::CapacityExceeded);
247                }
248                let mut value = DataVec::new();
249                for _ in 0..len {
250                    let v = $frag_id::decode(par)?;
251                    value.push(v);
252                }
253                Ok(value)
254            }
255            #[cfg(feature = "test_gen")]
256            use $crate::val_gen::ValGen;
257            #[cfg(feature = "test_gen")]
258            pub fn generate<FR, LR, RR>(
259                asm: &mut Assembler,
260                val_gen: &mut ValGen<FR, LR, RR>,
261                len: usize,
262            ) -> Result<(), RtcmError>
263            where
264                FR: rand::Rng,
265                LR: rand::Rng,
266                RR: rand::Rng,
267            {
268                for _ in 0..len {
269                    $frag_id::generate(asm, val_gen)?;
270                }
271                Ok(())
272            }
273        }
274    };
275}
276
277#[allow(unused)]
278macro_rules! frag_vec_with_len {
279    (
280        id: $id:ident,
281        frag_id: $frag_id:ident,
282        cap: $cap_name:ident,
283        len_bits: $len_bits:literal,
284    ) => {
285        pub mod $id {
286            use super::*;
287            use $crate::df::bit_value::U16;
288            use $crate::df::{assembler::Assembler, parser::Parser};
289            use $crate::msg::*;
290            use $crate::rtcm_error::RtcmError;
291            use $crate::util::DataVec;
292
293            // pub const $cap_name: usize = $cap;
294
295            pub mod export_types {
296                // pub use super::$cap_name;
297                pub use super::$frag_id::export_types::*;
298            }
299
300            pub type DataType = DataVec<$frag_id::DataType, $cap_name>;
301            pub fn encode(asm: &mut Assembler, value: &DataType) -> Result<(), RtcmError> {
302                let len = value.len() as u16;
303                asm.put::<U16>(len, $len_bits)?;
304
305                for v in value.iter() {
306                    $frag_id::encode(asm, v)?;
307                }
308                Ok(())
309            }
310            pub fn decode(par: &mut Parser) -> Result<DataType, RtcmError> {
311                let len = par.parse::<U16>($len_bits)? as usize;
312                if len > $cap_name {
313                    return Err(RtcmError::CapacityExceeded);
314                }
315                let mut value = DataVec::new();
316                for _ in 0..len {
317                    let v = $frag_id::decode(par)?;
318                    value.push(v);
319                }
320                Ok(value)
321            }
322            #[cfg(feature = "test_gen")]
323            use $crate::val_gen::ValGen;
324            #[cfg(feature = "test_gen")]
325            pub fn generate<FR, LR, RR>(
326                asm: &mut Assembler,
327                val_gen: &mut ValGen<FR, LR, RR>,
328            ) -> Result<(), RtcmError>
329            where
330                FR: rand::Rng,
331                LR: rand::Rng,
332                RR: rand::Rng,
333            {
334                let len = if val_gen.len_rng.gen::<u64>() == u64::MAX {
335                    $cap_name as u16
336                } else {
337                    val_gen.len_rng.gen::<u16>() % ($cap_name as u16 + 1)
338                };
339                asm.put::<U16>(len, $len_bits)?;
340                for _ in 0..len {
341                    $frag_id::generate(asm, val_gen)?;
342                }
343                Ok(())
344            }
345        }
346    };
347}
348
349#[allow(unused)]
350macro_rules! frag_grid16p {
351    (
352        id: $id:ident,
353        frag_id: $frag_id:ident,
354    ) => {
355        pub mod $id {
356            #[allow(unused)]
357            use super::*;
358            #[allow(unused)]
359            use $crate::df::dfs::*;
360            use $crate::df::{assembler::Assembler, parser::Parser};
361            #[allow(unused)]
362            use $crate::msg::*;
363            use $crate::rtcm_error::RtcmError;
364            use $crate::util::Grid16P;
365
366            pub mod export_types {
367                pub use super::$frag_id::export_types::*;
368            }
369
370            pub type DataType = Grid16P<$frag_id::DataType>;
371            pub fn encode(asm: &mut Assembler, value: &DataType) -> Result<(), RtcmError> {
372                for v in value.iter() {
373                    $frag_id::encode(asm, v)?;
374                }
375                Ok(())
376            }
377            pub fn decode(par: &mut Parser) -> Result<DataType, RtcmError> {
378                let mut value = Grid16P::new();
379                for v in value.iter_mut() {
380                    *v = $frag_id::decode(par)?;
381                }
382                Ok(value)
383            }
384            #[cfg(feature = "test_gen")]
385            use $crate::val_gen::ValGen;
386            #[cfg(feature = "test_gen")]
387            pub fn generate<FR, LR, RR>(
388                asm: &mut Assembler,
389                val_gen: &mut ValGen<FR, LR, RR>,
390            ) -> Result<(), RtcmError>
391            where
392                FR: rand::Rng,
393                LR: rand::Rng,
394                RR: rand::Rng,
395            {
396                for _ in 0..16 {
397                    $frag_id::generate(asm, val_gen)?;
398                }
399                Ok(())
400            }
401        }
402    };
403}
404
405#[allow(unused)]
406macro_rules! msm_data_seg_frag {
407    (
408        id: $id:ident,
409        type_name: $type_name:ident,
410        gnss: $gnss:ident,
411        sat_id: $sat_id:ident,
412        sig_id: $sig_id:ident,
413    ) => {
414        pub mod $id {
415            use super::*;
416            use $crate::df::bit_value::{U32, U64};
417            use $crate::df::{assembler::Assembler, parser::Parser};
418            use $crate::msg::{
419                cell_mask_id_vec, mask_len_u32, mask_len_u64, msm_mappings::$gnss::*,
420            };
421            use $crate::rtcm_error::RtcmError;
422            use $crate::tinyvec::ArrayVec;
423            #[cfg(feature = "serde")]
424            use $crate::{Deserialize, Serialize};
425
426            pub mod export_types {
427                #[allow(unused)]
428                pub use super::$sat_id::export_types::*;
429                pub use super::$sig_id::export_types::*;
430
431                pub use super::$type_name;
432            }
433
434            #[derive(Default, Clone, Debug, PartialEq)]
435            #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "sd"))]
436            pub struct $type_name {
437                pub satellite_data: $sat_id::DataType,
438                pub signal_data: $sig_id::DataType,
439            }
440            pub type DataType = $type_name;
441            pub fn encode(asm: &mut Assembler, value: &$type_name) -> Result<(), RtcmError> {
442                let mut sat_mask: u64 = 0;
443                for s in value.satellite_data.iter() {
444                    if s.satellite_id > 0 && s.satellite_id <= 64 {
445                        let sat: u64 = 1 << (64 - s.satellite_id);
446                        if sat & sat_mask > 0 {
447                            return Err(RtcmError::DuplicateSatellite);
448                        }
449                        sat_mask |= sat;
450                    } else {
451                        return Err(RtcmError::InvalidSatelliteId);
452                    }
453                }
454                let mut sig_mask: u32 = 0;
455                let mut sat_sig_mask: u64 = 0;
456                let mut cell_vec: ArrayVec<[(u8, u8); 64]> = ArrayVec::new();
457                for s in value.signal_data.iter() {
458                    let sat_id = if s.satellite_id > 0 && s.satellite_id <= 64 {
459                        s.satellite_id
460                    } else {
461                        return Err(RtcmError::InvalidSatelliteId);
462                    };
463                    let sig_id = if let Some(signal_id) = to_id(s.signal_id) {
464                        signal_id
465                    } else {
466                        return Err(RtcmError::InvalidSignalId);
467                    };
468                    let sat: u64 = 1 << (64 - sat_id);
469                    sat_sig_mask |= sat;
470                    let sig = 1 << (32 - sig_id);
471                    sig_mask |= sig;
472                    cell_vec.push((sat_id, sig_id));
473                }
474                if sat_mask != sat_sig_mask {
475                    return Err(RtcmError::SatelliteMismatch);
476                }
477                let mut sat_indx = [0usize; 64];
478                let mut sig_indx = [0usize; 32];
479                let mut indx_counter = 0;
480                for i in 0..64 {
481                    if (sat_mask >> (63 - i)) % 2 == 1 {
482                        sat_indx[i] = indx_counter;
483                        indx_counter += 1;
484                    }
485                }
486                indx_counter = 0;
487                for i in 0..32 {
488                    if (sig_mask >> (31 - i)) % 2 == 1 {
489                        sig_indx[i] = indx_counter;
490                        indx_counter += 1;
491                    }
492                }
493                let sig_mask_len = mask_len_u32(sig_mask);
494                let cell_cont_len = sig_mask_len * value.satellite_data.len();
495                let mut cell_mask: u64 = 0;
496                for (sat_id, sig_id) in cell_vec {
497                    let cell_indx = sat_indx[sat_id as usize - 1] * sig_mask_len
498                        + sig_indx[sig_id as usize - 1];
499                    let cell = 1 << (cell_cont_len - 1 - cell_indx);
500                    if cell & cell_mask > 0 {
501                        return Err(RtcmError::DuplicateSatelliteSignal);
502                    }
503                    cell_mask |= cell;
504                }
505                asm.put::<U64>(sat_mask, 64)?;
506                asm.put::<U32>(sig_mask, 32)?;
507                asm.put::<U64>(cell_mask, cell_cont_len)?;
508
509                $sat_id::encode(asm, &value.satellite_data)?;
510                $sig_id::encode(asm, &value.signal_data)?;
511                Ok(())
512            }
513            pub fn decode(par: &mut Parser) -> Result<$type_name, RtcmError> {
514                let sat_mask = par.parse::<U64>(64)?;
515                let sig_mask = par.parse::<U32>(32)?;
516
517                let sat_len = mask_len_u64(sat_mask);
518                let sig_len = mask_len_u32(sig_mask);
519
520                let cell_mask = par.parse::<U64>(sat_len * sig_len)?;
521                if let Some((sat_vec, cell_vec)) = cell_mask_id_vec(sat_mask, sig_mask, cell_mask) {
522                    let satellite_data = $sat_id::decode(par, &sat_vec)?;
523                    let signal_data = $sig_id::decode(par, &cell_vec)?;
524                    Ok($type_name {
525                        satellite_data,
526                        signal_data,
527                    })
528                } else {
529                    return Err(RtcmError::InvalidSatelliteSignalCount);
530                }
531            }
532            #[cfg(feature = "test_gen")]
533            use $crate::val_gen::ValGen;
534            #[cfg(feature = "test_gen")]
535            pub fn generate<FR, LR, RR>(
536                asm: &mut Assembler,
537                val_gen: &mut ValGen<FR, LR, RR>,
538            ) -> Result<(), RtcmError>
539            where
540                FR: rand::Rng,
541                LR: rand::Rng,
542                RR: rand::Rng,
543            {
544                let sig_len: usize = (val_gen.len_rng.gen::<usize>() % 64) + 1;
545                let subset: usize = val_gen.rng_rng.gen::<usize>();
546                let mut cell_vec: ArrayVec<[(u8, u8); 64]> = ArrayVec::new();
547                let mut sat_mask: u64 = 0;
548                let mut sig_mask: u32 = 0;
549                let mut sat_num: usize = 0;
550                let mut sig_num: usize = 0;
551                for _ in 0..sig_len {
552                    let (sat_id, sig_id) = loop {
553                        let sat_id: u8 = (((subset % 65) as u8
554                            + (val_gen.rng_rng.gen::<u8>() % (64 / id_len_div64() as u8)))
555                            % 64)
556                            + 1;
557                        let sig_id = random_id(&mut val_gen.rng_rng, subset);
558                        if !cell_vec.iter().any(|e| e.0 == sat_id && e.1 == sig_id) {
559                            break (sat_id, sig_id);
560                        }
561                    };
562                    cell_vec.push((sat_id, sig_id));
563                    let sat: u64 = 1 << (64 - sat_id);
564                    if (sat_mask & sat) == 0 {
565                        sat_num += 1;
566                    }
567                    sat_mask |= sat;
568                    let sig: u32 = 1 << (32 - sig_id);
569                    if (sig_mask & sig) == 0 {
570                        sig_num += 1;
571                    }
572                    sig_mask |= sig;
573                }
574                let cell_cont_len = sig_num * sat_num;
575                let mut sat_indx = [0usize; 64];
576                let mut sig_indx = [0usize; 32];
577                let mut indx_counter = 0;
578                for i in 0..64 {
579                    if (sat_mask >> (63 - i)) % 2 == 1 {
580                        sat_indx[i] = indx_counter;
581                        indx_counter += 1;
582                    }
583                }
584                indx_counter = 0;
585                for i in 0..32 {
586                    if (sig_mask >> (31 - i)) % 2 == 1 {
587                        sig_indx[i] = indx_counter;
588                        indx_counter += 1;
589                    }
590                }
591                let mut cell_mask: u64 = 0;
592                for (sat_id, sig_id) in cell_vec {
593                    let cell_indx =
594                        sat_indx[sat_id as usize - 1] * sig_num + sig_indx[sig_id as usize - 1];
595                    let cell: u64 = 1 << (cell_cont_len - 1 - cell_indx);
596                    debug_assert_eq!(cell & cell_mask, 0);
597                    cell_mask |= cell;
598                }
599                asm.put::<U64>(sat_mask, 64)?;
600                asm.put::<U32>(sig_mask, 32)?;
601                asm.put::<U64>(cell_mask, cell_cont_len)?;
602                $sat_id::generate(asm, val_gen, sat_mask)?;
603                $sig_id::generate(asm, val_gen, sig_len)?;
604
605                Ok(())
606            }
607
608            #[cfg(feature = "test_gen")]
609            impl $crate::source_repr::SourceRepr for $type_name {
610                fn to_source(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
611                    use core::fmt::Write;
612
613                    write!(f, "{} {{", stringify!($type_name))?;
614                    f.write_str("satellite_data: ")?;
615                    self.satellite_data.to_source(f)?;
616                    f.write_str(", signal_data: ")?;
617                    self.signal_data.to_source(f)?;
618                    f.write_char('}')?;
619
620                    Ok(())
621                }
622            }
623        }
624    };
625}
626#[allow(unused)]
627fn mask_len_u32(sat_mask: u32) -> usize {
628    let mut counter: usize = 0;
629    for sh in 0..32 {
630        counter += ((sat_mask >> sh) % 2) as usize;
631    }
632    counter
633}
634#[allow(unused)]
635fn mask_len_u64(sat_mask: u64) -> usize {
636    let mut counter: usize = 0;
637    for sh in 0..64 {
638        counter += ((sat_mask >> sh) % 2) as usize;
639    }
640    counter
641}
642#[allow(unused)]
643macro_rules! msm_sat_frag {
644    (
645        id: $id:ident,
646        type_name: $type_name:ident,
647        fields: [ $( ( $field_name:ident, $frag_id:ident ) ),+ ],
648    ) => {
649        pub mod $id {
650            use $crate::util::DataVec;
651            use $crate::df::{assembler::Assembler, parser::Parser};
652            use $crate::df::dfs::*;
653            use $crate::rtcm_error::RtcmError;
654            use $crate::tinyvec::ArrayVec;
655            #[cfg(feature = "serde")]
656            use $crate::{Serialize,Deserialize};
657
658            pub mod export_types {
659                $(
660                    #[allow(unused)]
661                    pub use super::$frag_id::export_types::*;
662                )+
663
664                pub use super::$type_name;
665            }
666
667            #[derive(Default,Clone, Debug, PartialEq)]
668            #[cfg_attr(feature="serde",derive(Serialize,Deserialize),serde(crate = "sd"))]
669            pub struct $type_name {
670                pub satellite_id: u8,
671                $(pub $field_name:$frag_id::DataType),+
672            }
673            pub type DataType = DataVec<$type_name,64>;
674            pub fn encode(asm:&mut Assembler, value:&DataType) -> Result<(),RtcmError> {
675                let mut value = value.clone();
676                let slice = value.as_mut_slice();
677                slice.sort_unstable_by(|a,b| a.satellite_id.cmp(&b.satellite_id));
678                $(
679                    for v in value.iter() {
680                        $frag_id::encode(asm, &v.$field_name)?;
681                    }
682                )+
683                Ok(())
684            }
685            pub fn decode(par:&mut Parser, sat_vec:&ArrayVec<[u8;64]>) -> Result<DataType,RtcmError> {
686                let mut value = DataVec::<$type_name,64>::new();
687                value.set_len(sat_vec.len());
688                {
689                    let mut iter = value.iter_mut();
690                    for s in sat_vec {
691                        let v = iter.next().unwrap();
692                        v.satellite_id = *s;
693                    }
694                }
695                $(
696                    for v in value.iter_mut() {
697                        v.$field_name = $frag_id::decode(par)?;
698                    }
699                )+
700                Ok(value)
701            }
702            #[cfg(feature = "test_gen")]
703            use $crate::val_gen::ValGen;
704            #[cfg(feature = "test_gen")]
705            pub fn generate<FR,LR,RR>(asm:&mut Assembler, val_gen:&mut ValGen<FR,LR,RR>, sat_mask:u64) -> Result<(),RtcmError>
706            where FR:rand::Rng, LR:rand::Rng, RR:rand::Rng {
707
708                let mut sat_len:usize = 0;
709                for i in 0..64 {
710                    if (sat_mask >> (63-i)) % 2 == 1 {
711                        sat_len += 1;
712                    }
713                }
714                $(
715                    for _ in 0..sat_len {
716                        $frag_id::generate(asm, val_gen)?;
717                    }
718                )+
719
720                Ok(())
721            }
722            #[cfg(feature = "test_gen")]
723            impl $crate::source_repr::SourceRepr for $type_name {
724                fn to_source(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
725                    use core::fmt::Write;
726
727                    write!(f, "{} {{", stringify!($type_name))?;
728                    f.write_str("satellite_id:")?;
729                    self.satellite_id.to_source(f)?;
730                    f.write_char(',')?;
731
732                    $(
733                        write!(f, "{}:", stringify!($field_name))?;
734                        self.$field_name.to_source(f)?;
735                        f.write_char(',')?;
736                    )+
737                    f.write_char('}')?;
738
739                    Ok(())
740                }
741            }
742        }
743    };
744}
745#[allow(unused)]
746macro_rules! msm_sig_frag {
747    (
748        id: $id:ident,
749        type_name: $type_name:ident,
750        gnss: $gnss:ident,
751        fields: [ $( ( $field_name:ident, $frag_id:ident ) ),+ ],
752    ) => {
753        pub mod $id {
754            use $crate::util::DataVec;
755            use $crate::df::{assembler::Assembler, parser::Parser};
756            use $crate::df::dfs::*;
757            use $crate::rtcm_error::RtcmError;
758            use $crate::tinyvec::ArrayVec;
759            use $crate::msg::msm_mappings::$gnss::*;
760            #[cfg(feature = "serde")]
761            use $crate::{Serialize,Deserialize};
762
763            pub mod export_types {
764                $(
765                    #[allow(unused)]
766                    pub use super::$frag_id::export_types::*;
767                )+
768
769                pub use super::$type_name;
770            }
771
772            #[derive(Default, Clone, Debug, PartialEq)]
773            #[cfg_attr(feature="serde",derive(Serialize,Deserialize),serde(crate = "sd"))]
774            pub struct $type_name {
775                pub satellite_id:u8,
776                pub signal_id:SigId,
777                $(pub $field_name:$frag_id::DataType),+
778            }
779            pub type DataType = DataVec<$type_name,64>;
780            pub fn encode(asm:&mut Assembler, value:&DataType) -> Result<(),RtcmError> {
781                let mut value = value.clone();
782                let slice = value.as_mut_slice();
783                slice.sort_unstable_by(|a,b| {
784                    match a.satellite_id.cmp(&b.satellite_id) {
785                        core::cmp::Ordering::Less => core::cmp::Ordering::Less,
786                        core::cmp::Ordering::Equal => a.signal_id.cmp(&b.signal_id),
787                        core::cmp::Ordering::Greater => core::cmp::Ordering::Greater,
788                    }
789                });
790                $(
791                    for v in value.iter() {
792                        $frag_id::encode(asm, &v.$field_name)?;
793                    }
794                )+
795                Ok(())
796            }
797            pub fn decode(par:&mut Parser, cell_vec:&ArrayVec<[(u8,u8);64]>) -> Result<DataType,RtcmError> {
798                let mut value = DataVec::<$type_name,64>::new();
799                value.set_len(cell_vec.len());
800                {
801                    let mut iter = value.iter_mut();
802                    for cv in cell_vec {
803                        let v = iter.next().unwrap();
804                        v.satellite_id = cv.0;
805                        v.signal_id = if let Some(v) = to_sig(cv.1) {
806                            v
807                        } else {
808                            return Err(RtcmError::InvalidSignalId);
809                        }
810                    }
811                }
812                $(
813                    for v in value.iter_mut() {
814                        v.$field_name = $frag_id::decode(par)?;
815                    }
816                )+
817                Ok(value)
818            }
819            #[cfg(feature = "test_gen")]
820            use $crate::val_gen::ValGen;
821            #[cfg(feature = "test_gen")]
822            pub fn generate<FR,LR,RR>(asm:&mut Assembler, val_gen:&mut ValGen<FR,LR,RR>, sig_len:usize) -> Result<(),RtcmError>
823            where FR:rand::Rng, LR:rand::Rng, RR:rand::Rng {
824                $(
825                    for _ in 0..sig_len {
826                        $frag_id::generate(asm, val_gen)?;
827                    }
828                )+
829                Ok(())
830            }
831            #[cfg(feature = "test_gen")]
832            impl $crate::source_repr::SourceRepr for $type_name {
833                fn to_source(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
834                    use core::fmt::Write;
835
836                    write!(f, "{} {{", stringify!($type_name))?;
837                    f.write_str("satellite_id: ")?;
838                    self.satellite_id.to_source(f)?;
839                    write!(f, ", signal_id: {}::", stringify!($gnss))?;
840                    self.signal_id.to_source(f)?;
841                    f.write_char(',')?;
842
843                    $(
844                        write!(f, "{}: ", stringify!($field_name))?;
845                        self.$field_name.to_source(f)?;
846                        f.write_char(',')?;
847                    )+
848                    f.write_char('}')?;
849
850                    Ok(())
851                }
852            }
853        }
854    };
855}
856#[allow(unused)]
857fn mask_to_id_vec_u32(mask: u32) -> ArrayVec<[u8; 32]> {
858    let mut indx_vec = ArrayVec::new();
859    for i in 0..32 {
860        if (mask >> (31 - i)) % 2 == 1 {
861            indx_vec.push(i + 1);
862        }
863    }
864    indx_vec
865}
866#[allow(unused)]
867fn mask_to_id_vec_u64(mask: u64) -> ArrayVec<[u8; 64]> {
868    let mut indx_vec = ArrayVec::new();
869    for i in 0..64 {
870        if (mask >> (63 - i)) % 2 == 1 {
871            indx_vec.push(i + 1);
872        }
873    }
874    indx_vec
875}
876#[allow(unused)]
877fn cell_mask_id_vec(
878    sat_mask: u64,
879    sig_mask: u32,
880    cell_mask: u64,
881) -> Option<(ArrayVec<[u8; 64]>, ArrayVec<[(u8, u8); 64]>)> {
882    let sat_vec = mask_to_id_vec_u64(sat_mask);
883    let sig_vec = mask_to_id_vec_u32(sig_mask);
884    let cell_cont_len = sat_vec.len() * sig_vec.len();
885    if cell_cont_len > 64 || cell_cont_len == 0 {
886        return None;
887    }
888    let mut cell_vec = ArrayVec::new();
889    for i in 0..cell_cont_len {
890        if (cell_mask >> (cell_cont_len - 1 - i)) % 2 == 1 {
891            cell_vec.push((sat_vec[i / sig_vec.len()], sig_vec[i % sig_vec.len()]));
892        }
893    }
894    Some((sat_vec, cell_vec))
895}
896
897//Common constants
898pub const DESC_CAP: usize = 31;
899pub const DB_LINK_CAP: usize = 7;
900pub const SAT_CAP_LEGACY: usize = 31;
901pub const SAT_CAP_MAC: usize = 15;
902pub const SAT_CAP_FKP: usize = 31;
903pub const SAT_CAP_RES: usize = 31;
904pub const SAT_CAP_1013: usize = 31;
905pub const SAT_CAP_1057: usize = 60;
906pub const SAT_CAP_1058: usize = 63;
907pub const SAT_CAP_1059: usize = 390;
908pub const SAT_CAP_1060: usize = 39;
909pub const SAT_CAP_1061: usize = 63;
910pub const SAT_CAP_1062: usize = 63;
911pub const SAT_CAP_1063: usize = 60;
912pub const SAT_CAP_1064: usize = 63;
913pub const SAT_CAP_1065: usize = 390;
914pub const SAT_CAP_1066: usize = 39;
915pub const SAT_CAP_1067: usize = 63;
916pub const SAT_CAP_1068: usize = 63;
917
918#[cfg(any(
919    feature = "msg1071",
920    feature = "msg1072",
921    feature = "msg1073",
922    feature = "msg1081",
923    feature = "msg1082",
924    feature = "msg1083",
925    feature = "msg1091",
926    feature = "msg1092",
927    feature = "msg1093",
928    feature = "msg1101",
929    feature = "msg1102",
930    feature = "msg1103",
931    feature = "msg1111",
932    feature = "msg1112",
933    feature = "msg1113",
934    feature = "msg1121",
935    feature = "msg1122",
936    feature = "msg1123",
937    feature = "msg1131",
938    feature = "msg1132",
939    feature = "msg1133"
940))]
941mod msm123_sat;
942
943#[cfg(any(
944    feature = "msg1074",
945    feature = "msg1076",
946    feature = "msg1084",
947    feature = "msg1086",
948    feature = "msg1094",
949    feature = "msg1096",
950    feature = "msg1104",
951    feature = "msg1106",
952    feature = "msg1114",
953    feature = "msg1116",
954    feature = "msg1124",
955    feature = "msg1126",
956    feature = "msg1134",
957    feature = "msg1136"
958))]
959mod msm46_sat;
960
961#[cfg(any(
962    feature = "msg1075",
963    feature = "msg1077",
964    feature = "msg1095",
965    feature = "msg1097",
966    feature = "msg1105",
967    feature = "msg1107",
968    feature = "msg1115",
969    feature = "msg1117",
970    feature = "msg1125",
971    feature = "msg1127",
972    feature = "msg1135",
973    feature = "msg1137"
974))]
975mod msm57_sat;
976
977#[cfg(any(feature = "msg1085", feature = "msg1087"))]
978mod msm57_glo_sat;
979
980macro_rules! include_msg {
981    ($msg:ident, $feature:literal) => {
982        #[cfg(feature = $feature)]
983        mod $msg;
984        #[cfg(feature = $feature)]
985        pub use $msg::$msg::export_types::*;
986    };
987}
988
989include_msg!(msg1001, "msg1001");
990include_msg!(msg1002, "msg1002");
991include_msg!(msg1003, "msg1003");
992include_msg!(msg1004, "msg1004");
993include_msg!(msg1005, "msg1005");
994include_msg!(msg1006, "msg1006");
995include_msg!(msg1007, "msg1007");
996include_msg!(msg1008, "msg1008");
997include_msg!(msg1009, "msg1009");
998include_msg!(msg1010, "msg1010");
999include_msg!(msg1011, "msg1011");
1000include_msg!(msg1012, "msg1012");
1001include_msg!(msg1013, "msg1013");
1002include_msg!(msg1014, "msg1014");
1003include_msg!(msg1015, "msg1015");
1004include_msg!(msg1016, "msg1016");
1005include_msg!(msg1017, "msg1017");
1006include_msg!(msg1019, "msg1019");
1007include_msg!(msg1020, "msg1020");
1008include_msg!(msg1021, "msg1021");
1009include_msg!(msg1022, "msg1022");
1010include_msg!(msg1023, "msg1023");
1011include_msg!(msg1024, "msg1024");
1012include_msg!(msg1025, "msg1025");
1013include_msg!(msg1026, "msg1026");
1014include_msg!(msg1027, "msg1027");
1015include_msg!(msg1029, "msg1029");
1016include_msg!(msg1030, "msg1030");
1017include_msg!(msg1031, "msg1031");
1018include_msg!(msg1032, "msg1032");
1019include_msg!(msg1033, "msg1033");
1020include_msg!(msg1034, "msg1034");
1021include_msg!(msg1035, "msg1035");
1022include_msg!(msg1037, "msg1037");
1023include_msg!(msg1038, "msg1038");
1024include_msg!(msg1039, "msg1039");
1025include_msg!(msg1041, "msg1041");
1026include_msg!(msg1042, "msg1042");
1027include_msg!(msg1044, "msg1044");
1028include_msg!(msg1045, "msg1045");
1029include_msg!(msg1046, "msg1046");
1030include_msg!(msg1057, "msg1057");
1031include_msg!(msg1058, "msg1058");
1032include_msg!(msg1059, "msg1059");
1033include_msg!(msg1060, "msg1060");
1034include_msg!(msg1061, "msg1061");
1035include_msg!(msg1062, "msg1062");
1036include_msg!(msg1063, "msg1063");
1037include_msg!(msg1064, "msg1064");
1038include_msg!(msg1065, "msg1065");
1039include_msg!(msg1066, "msg1066");
1040include_msg!(msg1067, "msg1067");
1041include_msg!(msg1068, "msg1068");
1042include_msg!(msg1071, "msg1071");
1043include_msg!(msg1072, "msg1072");
1044include_msg!(msg1073, "msg1073");
1045include_msg!(msg1074, "msg1074");
1046include_msg!(msg1075, "msg1075");
1047include_msg!(msg1076, "msg1076");
1048include_msg!(msg1077, "msg1077");
1049include_msg!(msg1081, "msg1081");
1050include_msg!(msg1082, "msg1082");
1051include_msg!(msg1083, "msg1083");
1052include_msg!(msg1084, "msg1084");
1053include_msg!(msg1085, "msg1085");
1054include_msg!(msg1086, "msg1086");
1055include_msg!(msg1087, "msg1087");
1056include_msg!(msg1091, "msg1091");
1057include_msg!(msg1092, "msg1092");
1058include_msg!(msg1093, "msg1093");
1059include_msg!(msg1094, "msg1094");
1060include_msg!(msg1095, "msg1095");
1061include_msg!(msg1096, "msg1096");
1062include_msg!(msg1097, "msg1097");
1063include_msg!(msg1101, "msg1101");
1064include_msg!(msg1102, "msg1102");
1065include_msg!(msg1103, "msg1103");
1066include_msg!(msg1104, "msg1104");
1067include_msg!(msg1105, "msg1105");
1068include_msg!(msg1106, "msg1106");
1069include_msg!(msg1107, "msg1107");
1070include_msg!(msg1111, "msg1111");
1071include_msg!(msg1112, "msg1112");
1072include_msg!(msg1113, "msg1113");
1073include_msg!(msg1114, "msg1114");
1074include_msg!(msg1115, "msg1115");
1075include_msg!(msg1116, "msg1116");
1076include_msg!(msg1117, "msg1117");
1077include_msg!(msg1121, "msg1121");
1078include_msg!(msg1122, "msg1122");
1079include_msg!(msg1123, "msg1123");
1080include_msg!(msg1124, "msg1124");
1081include_msg!(msg1125, "msg1125");
1082include_msg!(msg1126, "msg1126");
1083include_msg!(msg1127, "msg1127");
1084include_msg!(msg1131, "msg1131");
1085include_msg!(msg1132, "msg1132");
1086include_msg!(msg1133, "msg1133");
1087include_msg!(msg1134, "msg1134");
1088include_msg!(msg1135, "msg1135");
1089include_msg!(msg1136, "msg1136");
1090include_msg!(msg1137, "msg1137");
1091include_msg!(msg1230, "msg1230");
1092include_msg!(msg1300, "msg1300");
1093include_msg!(msg1301, "msg1301");
1094include_msg!(msg1302, "msg1302");
1095include_msg!(msg1303, "msg1303");
1096include_msg!(msg1304, "msg1304");
rtcm_rs/msg/mod.rs

rtcm_rs/msg/
mod.rs
