Merge PR oxibus#22: Added missing Attribute Definitions

Author: jannes922

src/lib.rs

@@ -577,15 +577,11 @@ pub struct AttributeValueForObject {
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize))]
 pub enum AttributeDefinition {
-    // TODO add properties
-    Message(String),
-    // TODO add properties
-    Node(String),
-    // TODO add properties
-    Signal(String),
-    EnvironmentVariable(String),
-    // TODO figure out name
-    Plain(String),
+    Message(String, AttributeValueType),
+    Node(String, AttributeValueType),
+    Signal(String, AttributeValueType),
+    EnvironmentVariable(String, AttributeValueType),
+    Plain(String, AttributeValueType),
 }
 
 /// Encoding for signal raw values.

src/parser.rs

@@ -19,17 +19,70 @@ use nom::bytes::complete::{escaped, take_till1};
 use nom::character::complete::one_of;
 use crate::{
     AccessNode, AccessType, AttributeDefault, AttributeDefinition, AttributeValue,
-    AttributeValueForObject, AttributeValuedForObjectType, Baudrate, ByteOrder, Comment, EnvType,
-    EnvironmentVariable, EnvironmentVariableData, ExtendedMultiplex, ExtendedMultiplexMapping,
-    Message, MessageId, MessageTransmitter, MultiplexIndicator, Node, Signal,
-    SignalExtendedValueType, SignalExtendedValueTypeList, SignalGroups, SignalType, SignalTypeRef,
-    Symbol, Transmitter, ValDescription, ValueDescription, ValueTable, ValueType, Version, DBC,
+    AttributeValueForObject, AttributeValueType, AttributeValuedForObjectType, Baudrate, ByteOrder,
+    Comment, EnvType, EnvironmentVariable, EnvironmentVariableData, ExtendedMultiplex,
+    ExtendedMultiplexMapping, Message, MessageId, MessageTransmitter, MultiplexIndicator, Node,
+    Signal, SignalExtendedValueType, SignalExtendedValueTypeList, SignalGroups, SignalType,
+    SignalTypeRef, Symbol, Transmitter, ValDescription, ValueDescription, ValueTable, ValueType,
+    Version, DBC,
 };
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn attribute_value_type_int_test() {
+        let (_, attr_val) =
+            attribute_value_type_int("INT -1 100").expect("Parsing INT attr definition failed");
+        assert_eq!(attr_val, AttributeValueType::AttributeValueTypeInt(-1, 100));
+    }
+    #[test]
+    fn attribute_value_type_test() {
+        let (_, attr_val) =
+            attribute_value_type("INT -1 100 ;\n").expect("Parsing INT attr definition failed");
+        assert_eq!(attr_val, AttributeValueType::AttributeValueTypeInt(-1, 100));
+
+        let (_, attr_val) =
+            attribute_value_type("HEX -1 100 ;\n").expect("Parsing HEX attr definition failed");
+        assert_eq!(attr_val, AttributeValueType::AttributeValueTypeHex(-1, 100));
+
+        let (_, attr_val) =
+            attribute_value_type("STRING ;\n").expect("Parsing STRING attr definition failed");
+        assert_eq!(attr_val, AttributeValueType::AttributeValueTypeString);
+
+        let (_, attr_val) =
+            attribute_value_type("FLOAT 0.2 1.7;\n").expect("Parsing FLOAT attr definition failed");
+        assert_eq!(
+            attr_val,
+            AttributeValueType::AttributeValueTypeFloat(0.2f64, 1.7f64)
+        );
+
+        let (_, attr_val) =
+            attribute_value_type("ENUM \"NEE\" , \"OCH\",  \"MENSCH\" , \"DOCH\";\n")
+                .expect("Parsing ENUM attr definition failed");
+        assert_eq!(
+            attr_val,
+            AttributeValueType::AttributeValueTypeEnum(vec![
+                "NEE".to_string(),
+                "OCH".to_string(),
+                "MENSCH".to_string(),
+                "DOCH".to_string()
+            ])
+        );
+
+        let (_, attr_val) =
+            attribute_value_type("ENUM \"NEE\";\n").expect("Parsing ENUM attr definition failed");
+        assert_eq!(
+            attr_val,
+            AttributeValueType::AttributeValueTypeEnum(vec!["NEE".to_string()])
+        );
+
+        let (_, attr_val) =
+            attribute_value_type("ENUM;\n").expect("Parsing ENUM attr definition failed");
+        assert_eq!(attr_val, AttributeValueType::AttributeValueTypeEnum(vec![]));
+    }
+
     #[test]
     fn c_ident_test() {
         let def1 = "EALL_DUSasb18 ";
@@ -436,23 +489,34 @@ mod tests {
     fn attribute_definition_test() {
         let def_bo = "BA_DEF_ BO_ \"BaDef1BO\" INT 0 1000000;\n";
         let (_, bo_def) = attribute_definition(def_bo).unwrap();
-        let bo_def_exp = AttributeDefinition::Message("\"BaDef1BO\" INT 0 1000000".to_string());
+        let bo_def_exp = AttributeDefinition::Message(
+            "BaDef1BO".to_string(),
+            AttributeValueType::AttributeValueTypeInt(0, 1000000),
+        );
         assert_eq!(bo_def_exp, bo_def);
 
         let def_bu = "BA_DEF_ BU_ \"BuDef1BO\" INT 0 1000000;\n";
         let (_, bu_def) = attribute_definition(def_bu).unwrap();
-        let bu_def_exp = AttributeDefinition::Node("\"BuDef1BO\" INT 0 1000000".to_string());
+        let bu_def_exp = AttributeDefinition::Node(
+            "BuDef1BO".to_string(),
+            AttributeValueType::AttributeValueTypeInt(0, 1000000),
+        );
         assert_eq!(bu_def_exp, bu_def);
 
         let def_signal = "BA_DEF_ SG_ \"SgDef1BO\" INT 0 1000000;\n";
         let (_, signal_def) = attribute_definition(def_signal).unwrap();
-        let signal_def_exp = AttributeDefinition::Signal("\"SgDef1BO\" INT 0 1000000".to_string());
+        let signal_def_exp = AttributeDefinition::Signal(
+            "SgDef1BO".to_string(),
+            AttributeValueType::AttributeValueTypeInt(0, 1000000),
+        );
         assert_eq!(signal_def_exp, signal_def);
 
         let def_env_var = "BA_DEF_ EV_ \"EvDef1BO\" INT 0 1000000;\n";
         let (_, env_var_def) = attribute_definition(def_env_var).unwrap();
-        let env_var_def_exp =
-            AttributeDefinition::EnvironmentVariable("\"EvDef1BO\" INT 0 1000000".to_string());
+        let env_var_def_exp = AttributeDefinition::EnvironmentVariable(
+            "EvDef1BO".to_string(),
+            AttributeValueType::AttributeValueTypeInt(0, 1000000),
+        );
         assert_eq!(env_var_def_exp, env_var_def);
     }
 
@@ -1336,45 +1400,136 @@ fn attribute_value_for_object(s: &str) -> IResult<&str, AttributeValueForObject>
     ))
 }
 
-// TODO add properties
 fn attribute_definition_node(s: &str) -> IResult<&str, AttributeDefinition> {
     let (s, _) = tag("BU_")(s)?;
     let (s, _) = ms1(s)?;
-    let (s, node) = take_till(is_semi_colon)(s)?;
-    Ok((s, AttributeDefinition::Node(node.to_string())))
+    let (s, name) = char_string(s)?;
+
+    let (s, _) = ms0(s)?;
+    let (s, val) = attribute_value_type(s)?;
+    Ok((s, AttributeDefinition::Node(name.to_string(), val)))
 }
 
-// TODO add properties
 fn attribute_definition_signal(s: &str) -> IResult<&str, AttributeDefinition> {
     let (s, _) = tag("SG_")(s)?;
     let (s, _) = ms1(s)?;
-    let (s, signal) = take_till(is_semi_colon)(s)?;
-    Ok((s, AttributeDefinition::Signal(signal.to_string())))
+    let (s, name) = char_string(s)?;
+
+    let (s, _) = ms0(s)?;
+    let (s, val) = attribute_value_type(s)?;
+    Ok((s, AttributeDefinition::Signal(name.to_string(), val)))
 }
 
-// TODO add properties
 fn attribute_definition_environment_variable(s: &str) -> IResult<&str, AttributeDefinition> {
     let (s, _) = tag("EV_")(s)?;
     let (s, _) = ms1(s)?;
-    let (s, env_var) = take_till(is_semi_colon)(s)?;
+    let (s, name) = char_string(s)?;
+
+    let (s, _) = ms0(s)?;
+    let (s, val) = attribute_value_type(s)?;
     Ok((
         s,
-        AttributeDefinition::EnvironmentVariable(env_var.to_string()),
+        AttributeDefinition::EnvironmentVariable(name.to_string(), val),
     ))
 }
 
-// TODO add properties
 fn attribute_definition_message(s: &str) -> IResult<&str, AttributeDefinition> {
     let (s, _) = tag("BO_")(s)?;
     let (s, _) = ms1(s)?;
-    let (s, message) = take_till(is_semi_colon)(s)?;
-    Ok((s, AttributeDefinition::Message(message.to_string())))
+    let (s, name) = char_string(s)?;
+
+    let (s, _) = ms0(s)?;
+    let (s, val) = attribute_value_type(s)?;
+    Ok((s, AttributeDefinition::Message(name.to_string(), val)))
 }
 
-// TODO add properties
 fn attribute_definition_plain(s: &str) -> IResult<&str, AttributeDefinition> {
-    let (s, plain) = take_till(is_semi_colon)(s)?;
-    Ok((s, AttributeDefinition::Plain(plain.to_string())))
+    let (s, name) = char_string(s)?;
+    let (s, val) = attribute_value_type(s)?;
+    Ok((s, AttributeDefinition::Plain(name.to_string(), val)))
+}
+
+fn attribute_value_type_int(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, _) = tag("INT")(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, first) = complete::i64(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, second) = complete::i64(s)?;
+
+    let (s, _) = ms0(s)?;
+    Ok((s, AttributeValueType::AttributeValueTypeInt(first, second)))
+}
+
+fn attribute_value_type_float(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, _) = tag("FLOAT")(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, first) = double(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, second) = double(s)?;
+
+    let (s, _) = ms0(s)?;
+    Ok((
+        s,
+        AttributeValueType::AttributeValueTypeFloat(first, second),
+    ))
+}
+
+fn attribute_value_type_hex(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, _) = tag("HEX")(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, first) = complete::i64(s)?;
+    let (s, _) = ms1(s)?;
+    let (s, second) = complete::i64(s)?;
+
+    let (s, _) = ms0(s)?;
+    Ok((s, AttributeValueType::AttributeValueTypeHex(first, second)))
+}
+
+fn attribute_value_type_string(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, _) = tag("STRING")(s)?;
+    let (s, _) = ms0(s)?;
+    Ok((s, AttributeValueType::AttributeValueTypeString))
+}
+
+fn attribute_value_type(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, val) = alt((
+        attribute_value_type_int,
+        attribute_value_type_hex,
+        attribute_value_type_float,
+        attribute_value_type_string,
+        attribute_value_type_enum,
+    ))(s)?;
+
+    Ok((s, val))
+}
+
+fn comma_seperated_char_string(s: &str) -> IResult<&str, String> {
+    let (s, _) = ms0(s)?;
+    let (s, _) = comma(s)?;
+    let (s, _) = ms0(s)?;
+    let (s, c_s) = char_string(s)?;
+    Ok((s, c_s.to_string()))
+}
+fn attribute_value_type_enum(s: &str) -> IResult<&str, AttributeValueType> {
+    let (s, _) = multispace0(s)?;
+    let (s, _) = tag("ENUM")(s)?;
+    let (s, _) = ms0(s)?;
+    let mut buffer: Vec<String> = vec![];
+
+    if let (s, Some(value)) = opt(char_string)(s)? {
+        buffer.push(value.to_string());
+        let (s, mut tail) = many0(comma_seperated_char_string)(s)?;
+        buffer.append(&mut tail);
+        Ok((s, AttributeValueType::AttributeValueTypeEnum(buffer)))
+    } else {
+        let (s, _) = ms0(s)?;
+        Ok((s, AttributeValueType::AttributeValueTypeEnum(buffer)))
+    }
 }
 
 fn attribute_definition(s: &str) -> IResult<&str, AttributeDefinition> {
@@ -1388,7 +1543,6 @@ fn attribute_definition(s: &str) -> IResult<&str, AttributeDefinition> {
         attribute_definition_message,
         attribute_definition_plain,
     ))(s)?;
-
     let (s, _) = semi_colon(s)?;
     let (s, _) = line_ending(s)?;
     Ok((s, def))