asterix_parser 0.1.1

Playground do Protocolo ASTERIX
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::collections::BTreeMap;
use bitvec::prelude::*;

use serde::{Deserialize, Serialize};

use super::traits::Describe;
use super::enums::{AttributeConstraintLimit, AttributeLsb, AttributeType, ConstraintType, DataItemType, DataRecordType, DataType, Uap};


#[derive(Default, Clone)]
pub struct FSpecInfo { 
    pub len: u8, 
    pub fspec:BTreeMap<u8, bool> 
}

#[derive(Clone)]
pub struct AttributeConstraint {
    pub constraint_type: ConstraintType,
    pub limit_value: AttributeConstraintLimit 
}

#[derive(Default, Clone) ]
pub struct Attribute {
    pub name: String,
    pub title: String,
    pub bits: BitVec<u8, Msb0>,
    pub value_type: String,
    pub stringfied_value: Option<String>,
    pub signed: Option<bool>,
    pub constraints: Option<Vec<AttributeConstraint>>,
    pub lsb: Option<AttributeLsb>,
    pub unit: Option<String>,
    pub description: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Date {
    pub day: u8,
    pub month: u8,
    pub year: u16,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash)]
#[serde(deny_unknown_fields)]
pub struct Edition {
    pub major: u32,
    pub minor: u32,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DataRecord {
    pub catalogue: Vec<DataItemRule>,
    pub date: Date,
    pub edition: Edition,
    pub number: u8,
    pub preamble: String,
    pub title: String,
    #[serde(rename = "type")]
    pub type_value: DataRecordType,
    pub uap: Uap,
}

impl Describe for DataRecord {
    fn describe(&self, indent_level: &mut usize) -> String {
        let self_description = format!("Category: {:03}, {}, edition: {}.{}", 
        self.number, 
        self.title, 
        self.edition.major,
        self.edition.minor);
        let mut description = vec![self.get_indented_description(indent_level, self_description)];

        for dataitem in &self.catalogue {
            description.push(dataitem.describe(indent_level));

            // println!("DataItem: {}, {}", dataitem.name, dataitem.title);
            // let describe = false;
            // if describe {
            //     if dataitem.name == "010" {
            //         description = describe_data_item(dataitem);
            //         println!("{}", description)
            //     }
            // }
        }
        
        description.join("\n")
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DataItemRule {
    pub definition: Option<String>,
    pub description: Option<String>,
    pub name: String,
    pub remark: Option<String>,
    pub rule: DataItemType,
    pub spare: bool,
    pub title: String,
}

impl Describe for DataItemRule {
    fn describe(&self, indent_level: &mut usize) -> String {
        let self_description = format!("DataItem: {:03}, {}, spare: {}", 
        self.name,
        self.title, 
        if self.spare { "true" } else {"false"});
        
        let mut description = vec![self.get_indented_description(indent_level, self_description)];

        let rule_desc: String;

        rule_desc = match &self.rule {
            DataItemType::ContextFree { value } => value.describe(indent_level),
        };
        
        description.push(rule_desc);
        description.join("\n")
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ConstraintRule {
    #[serde(rename = "type")]
    pub constraint_type: ConstraintType,
    pub value: DataType,
}


#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
pub struct  AttributeRule {
    pub definition: Option<String>,
    pub description: Option<String>,
    pub name: String,
    pub remark: Option<String>,
    pub rule: AttributeType,
    pub spare: bool,
    pub title: String,
}

impl Describe for AttributeRule {
    fn describe(&self, indent: &mut usize) -> String {
        self.get_indented_description(indent, format!("Attribute rule: {}, {}", self.name, self.title))
    }
}