From 52bd5c1f5e36990047e76872cc2fda6faeb87527 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Thu, 16 Feb 2023 17:42:02 +0100 Subject: [PATCH 1/9] Added Regex for Attributes Parsing --- DbcParserLib/Parsers/PropertiesLineParser.cs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index 5190c06..ef60a4d 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -8,6 +8,11 @@ namespace DbcParserLib.Parsers public class PropertiesLineParser : ILineParser { private const string PropertiesLineStarter = "BA_ "; + private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; + private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; + private const string PropertyParsingRegex = @"BA_\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|((BU_|EV_)\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)""))|((BO_)\s+(\d+)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)""))|((SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")))\s*;"; + private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_)\s+)([a-zA-Z_][\w]*)\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9].+)\s+([0-9.]+))|(STRING)|(?:(ENUM)\s+""([^""]*)""))\s*;"; + private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")\s*;"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { From ad2faebeb0e26c1738a684a6dfcea7910ccbe962 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Mon, 20 Feb 2023 17:05:03 +0100 Subject: [PATCH 2/9] Added Custom Properties support - Added support for BA_DEF_DEF_ tag - Added support for BA_DEF_ tag - Added support for BA_ tag --- DbcParserLib/DbcBuilder.cs | 181 ++++++++++++++++++- DbcParserLib/IDbcBuilder.cs | 5 + DbcParserLib/Model/Node.cs | 59 ++++++ DbcParserLib/Parsers/PropertiesLineParser.cs | 115 +++++++++--- 4 files changed, 333 insertions(+), 27 deletions(-) diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index 12be7cf..34f745d 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -1,6 +1,8 @@ using System.Collections.Generic; using System.Globalization; using System.Linq; +using System.Linq.Expressions; +using System.Xml.Linq; using DbcParserLib.Model; namespace DbcParserLib @@ -17,6 +19,7 @@ public class DbcBuilder : IDbcBuilder private readonly IDictionary m_namedTablesMap = new Dictionary(); private readonly IDictionary m_messages = new Dictionary(); private readonly IDictionary> m_signals = new Dictionary>(); + private readonly IDictionary> m_customProperties = new Dictionary>(); private Message m_currentMessage; @@ -41,6 +44,60 @@ public void AddSignal(Signal signal) } } + public void AddCustomProperty(DbcObjectType objectType, CustomProperty customProperty) + { + m_customProperties[objectType][customProperty.Name] = customProperty; + } + + public void AddCustomPropertyDefaultValue(string propertyName, string value) + { + foreach(var objectType in m_customProperties.Keys) + { + if (m_customProperties[objectType].TryGetValue(propertyName, out var customProperty)) + { + SetCustomPropertyDefaultValue(customProperty, value); + } + } + } + + public void AddNodeCustomProperty(string propertyName, string nodeName, string value) + { + if(m_customProperties[DbcObjectType.Node].TryGetValue(propertyName, out var customProperty)) + { + var node = m_nodes.FirstOrDefault(n => n.Name.Equals(nodeName)); + if (node != null) + { + SetCustomPropertyValue(customProperty, value); + node.CustomProperties[propertyName] = customProperty; + } + } + } + + public void AddMessageCustomProperty(string propertyName, uint messageId, string value) + { + if (m_customProperties[DbcObjectType.Message].TryGetValue(propertyName, out var customProperty)) + { + if (m_messages.TryGetValue(messageId, out var message)) + { + SetCustomPropertyValue(customProperty, value); + message.CustomProperties[propertyName] = customProperty; + } + + } + } + + public void AddSignalCustomProperty(string propertyName, uint messageId, string signalName, string value) + { + if (m_customProperties[DbcObjectType.Message].TryGetValue(propertyName, out var customProperty)) + { + if (TryGetValueMessageSignal(messageId, signalName, out var signal)) + { + SetCustomPropertyValue(customProperty, value); + signal.CustomProperties[propertyName] = customProperty; + } + } + } + public void AddSignalComment(uint messageId, string signalName, string comment) { if (TryGetValueMessageSignal(messageId, signalName, out var signal)) @@ -122,6 +179,14 @@ public static bool IsExtID(ref uint id) return false; } + public void LinkNamedTableToSignal(uint messageId, string signalName, string tableName) + { + if (m_namedTablesMap.TryGetValue(tableName, out var valuesTable)) + { + LinkTableValuesToSignal(messageId, signalName, valuesTable.ValueTableMap, valuesTable.ValueTable); + } + } + private bool TryGetValueMessageSignal(uint messageId, string signalName, out Signal signal) { if (m_signals.TryGetValue(messageId, out var signals) && signals.TryGetValue(signalName, out signal)) @@ -133,16 +198,126 @@ private bool TryGetValueMessageSignal(uint messageId, string signalName, out Sig return false; } - public void LinkNamedTableToSignal(uint messageId, string signalName, string tableName) + private void SetCustomPropertyValue(CustomProperty customProperty, string value) { - if (m_namedTablesMap.TryGetValue(tableName, out var valuesTable)) + switch (customProperty.DataType) { - LinkTableValuesToSignal(messageId, signalName, valuesTable.ValueTableMap, valuesTable.ValueTable); + case DbcDataType.Integer: + customProperty.IntegerCustomProperty.Value = int.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.Hex: + customProperty.HexCustomProperty.Value = int.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.Float: + customProperty.FloatCustomProperty.Value = float.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.String: + customProperty.StringCustomProperty.Value = value; + break; + case DbcDataType.Enum: + customProperty.EnumCustomProperty.Value = value.Split(','); + break; + } + } + + private void SetCustomPropertyDefaultValue(CustomProperty customProperty, string value) + { + switch (customProperty.DataType) + { + case DbcDataType.Integer: + customProperty.IntegerCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.Hex: + customProperty.HexCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.Float: + customProperty.FloatCustomProperty.Default = float.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.String: + customProperty.StringCustomProperty.Default = value; + break; + case DbcDataType.Enum: + customProperty.EnumCustomProperty.Default = value.Split(','); + break; + } + } + + private void SetCustomPropertyValueFromDefault(CustomProperty customProperty) + { + switch (customProperty.DataType) + { + case DbcDataType.Integer: + customProperty.IntegerCustomProperty.Value = customProperty.IntegerCustomProperty.Default; + break; + case DbcDataType.Hex: + customProperty.HexCustomProperty.Value = customProperty.HexCustomProperty.Default; + break; + case DbcDataType.Float: + customProperty.FloatCustomProperty.Value = customProperty.FloatCustomProperty.Default; + break; + case DbcDataType.String: + customProperty.StringCustomProperty.Value = customProperty.StringCustomProperty.Default; + break; + case DbcDataType.Enum: + customProperty.EnumCustomProperty.Value = customProperty.EnumCustomProperty.Default; + break; + } + } + + private void FillNodesNotSetCustomPropertyWithDefault() + { + var nodeCustomProperties = m_customProperties[DbcObjectType.Node]; + foreach (var customProperty in nodeCustomProperties) + { + foreach (var node in m_nodes) + { + if (!node.CustomProperties.TryGetValue(customProperty.Key, out var property)) + { + SetCustomPropertyValueFromDefault(property); + node.CustomProperties[property.Name] = property; + } + } + } + } + + private void FillMesagesNotSetCustomPropertyWithDefault() + { + var messageCustomProperties = m_customProperties[DbcObjectType.Message]; + foreach (var customProperty in messageCustomProperties) + { + foreach (var message in m_messages.Values) + { + FillSignalsNotSetCustomPropertyWithDefault(message.ID); + if (!message.CustomProperties.TryGetValue(customProperty.Key, out var property)) + { + SetCustomPropertyValueFromDefault(property); + message.CustomProperties[property.Name] = property; + } + } + } + } + + private void FillSignalsNotSetCustomPropertyWithDefault(uint messageId) + { + var signalCustomProperties = m_customProperties[DbcObjectType.Signal]; + foreach (var customProperty in signalCustomProperties) + { + foreach (var signal in m_signals[messageId].Values) + { + if (!signal.CustomProperties.TryGetValue(customProperty.Key, out var property)) + { + SetCustomPropertyValueFromDefault(property); + signal.CustomProperties[property.Name] = property; + } + } } } public Dbc Build() { + FillNodesNotSetCustomPropertyWithDefault(); + FillMesagesNotSetCustomPropertyWithDefault(); + foreach (var message in m_messages) { message.Value.Signals.Clear(); diff --git a/DbcParserLib/IDbcBuilder.cs b/DbcParserLib/IDbcBuilder.cs index 81404a7..531ec4f 100644 --- a/DbcParserLib/IDbcBuilder.cs +++ b/DbcParserLib/IDbcBuilder.cs @@ -17,5 +17,10 @@ public interface IDbcBuilder void AddSignalValueType(uint messageId, string signalName, DbcValueType valueType); void LinkNamedTableToSignal(uint messageId, string signalName, string tableName); void LinkTableValuesToSignal(uint messageId, string signalName, IReadOnlyDictionary dictValues, string stringValues); + void AddCustomProperty(DbcObjectType objectType, CustomProperty customProperty); + void AddCustomPropertyDefaultValue(string propertyName, string value); + void AddNodeCustomProperty(string propertyName, string nodeName, string value); + void AddMessageCustomProperty(string propertyName, uint messageId, string value); + void AddSignalCustomProperty(string propertyName, uint messageId, string signalName, string value); } } \ No newline at end of file diff --git a/DbcParserLib/Model/Node.cs b/DbcParserLib/Model/Node.cs index 5488931..2a713c5 100644 --- a/DbcParserLib/Model/Node.cs +++ b/DbcParserLib/Model/Node.cs @@ -7,6 +7,7 @@ public class Node { public string Name; public string Comment; + public readonly IDictionary CustomProperties = new Dictionary(); } public class Message @@ -19,6 +20,7 @@ public class Message public string Comment; public int CycleTime; public List Signals = new List(); + public readonly IDictionary CustomProperties = new Dictionary(); } public class Signal @@ -57,6 +59,7 @@ public DbcValueType ValueType public IReadOnlyDictionary ValueTableMap { get; private set; } public string Comment; public string Multiplexing; + public readonly IDictionary CustomProperties = new Dictionary(); internal void SetValueTable(IReadOnlyDictionary dictValues, string stringValues) { @@ -65,6 +68,62 @@ internal void SetValueTable(IReadOnlyDictionary dictValues, string } } + public class CustomProperty + { + public string Name { get; set; } + public DbcDataType DataType { get; set; } + public IntegerCustomProperty IntegerCustomProperty { get; set; } + public HexCustomProperty HexCustomProperty { get; set; } + public FloatCustomProperty FloatCustomProperty { get; set; } + public StringCustomProperty StringCustomProperty { get; set; } + public EnumCustomProperty EnumCustomProperty { get; set; } + } + + public class IntegerCustomProperty + { + public int Maximum { get; set; } + public int Minimum { get; set; } + public int Default { get; set; } + public int Value { get; set; } + } + + public class HexCustomProperty + { + public int Maximum { get; set; } + public int Minimum { get; set; } + public int Default { get; set; } + public int Value { get; set; } + } + + public class FloatCustomProperty + { + public double Maximum { get; set; } + public double Minimum { get; set; } + public double Default { get; set; } + public double Value { get; set; } + } + public class StringCustomProperty + { + public string Default { get; set; } + public string Value { get; set; } + } + + public class EnumCustomProperty + { + public string[] Default { get; set; } + public string[] Value { get; set; } + } + + public enum DbcObjectType + { + Node, Message, Signal, Environment + } + + public enum DbcDataType + { + Integer, Hex, Float, String, Enum + } + public enum DbcValueType { Signed, Unsigned, IEEEFloat, IEEEDouble diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index ef60a4d..993715f 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -2,6 +2,7 @@ using System; using System.Globalization; using System.Linq; +using System.Text.RegularExpressions; namespace DbcParserLib.Parsers { @@ -10,48 +11,114 @@ public class PropertiesLineParser : ILineParser private const string PropertiesLineStarter = "BA_ "; private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; - private const string PropertyParsingRegex = @"BA_\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|((BU_|EV_)\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)""))|((BO_)\s+(\d+)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)""))|((SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")))\s*;"; - private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_)\s+)([a-zA-Z_][\w]*)\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9].+)\s+([0-9.]+))|(STRING)|(?:(ENUM)\s+""([^""]*)""))\s*;"; - private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+([a-zA-Z_][\w]*)\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")\s*;"; + private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"");"; + private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9.]+)\s+([0-9.]+))|(STRING)|(?:(ENUM)\s+""([^""]*)""))\s*;"; + private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")\s*;"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { - var cleanLine = line.Trim(' ', ';'); + var cleanLine = line.Trim(' '); if (cleanLine.StartsWith(PropertiesLineStarter) == false) return false; - if (cleanLine.StartsWith("BA_ \"GenMsgCycleTime\" BO_")) + if (cleanLine.StartsWith(PropertiesDefinitionDefaultLineStarter)) { - SetMessageCycleTime(cleanLine, builder); + var match = Regex.Match(cleanLine, PropertyDefinitionDefaultParsingRegex); + if (match.Success) + { + builder.AddCustomPropertyDefaultValue(match.Groups[1].Value, match.Groups[2].Value); + } return true; } - if (cleanLine.StartsWith("BA_ \"GenSigStartValue\" SG_")) + if (cleanLine.StartsWith(PropertiesDefinitionLineStarter)) { - SetSignalInitialValue(cleanLine, builder); - return true; - } + var match = Regex.Match(cleanLine, PropertyDefinitionParsingRegex); + if (match.Success) + { + var customProperty = new CustomProperty + { + Name = match.Groups[2].Value, + }; - return false; - } + DbcObjectType objectType = DbcObjectType.Node; + switch (match.Groups[1].Value) + { + case "BO_": + objectType = DbcObjectType.Message; break; + case "SG_": + objectType = DbcObjectType.Signal; break; + case "EV_": + objectType = DbcObjectType.Environment; break; + } - private static void SetMessageCycleTime(string msgCycleTimeStr, IDbcBuilder builder) - { - string[] records = msgCycleTimeStr.SplitBySpace(); - if (records.Length > 4 && uint.TryParse(records[3], out var messageId)) - { - builder.AddMessageCycleTime(messageId, int.Parse(records[4], CultureInfo.InvariantCulture)); + DbcDataType dataType = DbcDataType.Integer; + if (match.Groups[3].Value == "INT") + { + customProperty.IntegerCustomProperty = new IntegerCustomProperty + { + Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), + Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), + }; + } + else if (match.Groups[3].Value == "HEX") + { + dataType = DbcDataType.Hex; + customProperty.HexCustomProperty = new HexCustomProperty + { + Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), + Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), + }; + } + else if (match.Groups[6].Value == "FLOAT") + { + dataType = DbcDataType.Float; + customProperty.FloatCustomProperty = new FloatCustomProperty + { + Minimum = double.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), + Maximum = double.Parse(match.Groups[8].Value, CultureInfo.InvariantCulture), + }; + } + else if(match.Groups[9].Value == "STRING") + dataType = DbcDataType.String; + else if (match.Groups[10].Value == "ENUM") + { + dataType = DbcDataType.Enum; + customProperty.EnumCustomProperty = new EnumCustomProperty + { + Default = match.Groups[11].Value.Split(','), + }; + } + customProperty.DataType = dataType; + builder.AddCustomProperty(objectType, customProperty); + } + return true; } - } - private static void SetSignalInitialValue(string sigInitialValueStr, IDbcBuilder builder) - { - string[] records = sigInitialValueStr.SplitBySpace(); - if (records.Length > 4 && uint.TryParse(records[3], out var messageId)) + if (cleanLine.StartsWith(PropertiesLineStarter)) { - builder.AddSignalInitialValue(messageId, records[4], double.Parse(records[5], CultureInfo.InvariantCulture)); + var match = Regex.Match(cleanLine, PropertyParsingRegex); + if (match.Success) + { + if (match.Groups[4].Value == "BU_") + builder.AddNodeCustomProperty(match.Groups[1].Value, match.Groups[5].Value, match.Groups[6].Value); + if (match.Groups[4].Value == "BO_") + { + builder.AddMessageCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[10].Value, CultureInfo.InvariantCulture), match.Groups[3].Value); + if (match.Groups[1].Value == "GenMsgCycleTime") + builder.AddMessageCycleTime(uint.Parse(match.Groups[10].Value, CultureInfo.InvariantCulture), int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture)); + } + if (match.Groups[4].Value == "SG_") + { + builder.AddSignalCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[15].Value, CultureInfo.InvariantCulture), match.Groups[16].Value, match.Groups[17].Value); + if (match.Groups[1].Value == "GenSigStartValue") + builder.AddSignalInitialValue(uint.Parse(match.Groups[15].Value, CultureInfo.InvariantCulture), match.Groups[16].Value, double.Parse(match.Groups[17].Value, CultureInfo.InvariantCulture)); + } + } + return true; } + return false; } } } \ No newline at end of file From 4cc10a32ce4ace9e906fcd4c4ea71eede97d3968 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Mon, 20 Feb 2023 18:08:06 +0100 Subject: [PATCH 3/9] Add some tests and bug fixed Added test for: - Message custom property - Signal custom property - Node custom property Changed regex parsing string --- .../PropertiesLineParserTests.cs | 51 +++++++++++++++++++ DbcParserLib/DbcBuilder.cs | 11 ++-- DbcParserLib/Parsers/PropertiesLineParser.cs | 26 +++++----- 3 files changed, 72 insertions(+), 16 deletions(-) diff --git a/DbcParserLib.Tests/PropertiesLineParserTests.cs b/DbcParserLib.Tests/PropertiesLineParserTests.cs index 0cc764a..f93a43c 100644 --- a/DbcParserLib.Tests/PropertiesLineParserTests.cs +++ b/DbcParserLib.Tests/PropertiesLineParserTests.cs @@ -48,5 +48,56 @@ public void SigInitalValueIsParsed() Assert.AreEqual(40, dbc.Messages.First().Signals.First().InitialValue); } + [Test] + public void MsgCustomPropertyIsParsed() + { + var builder = new DbcBuilder(); + var message = new Message { ID = 2394947585 }; + message.IsExtID = DbcBuilder.IsExtID(ref message.ID); + builder.AddMessage(message); + + var msgCycleTimeLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_DEF_ BO_ ""GenMsgCycleTime"" INT 0 200;", builder, nextLineProvider)); + Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_DEF_DEF_ ""GenMsgCycleTime"" 150;", builder, nextLineProvider)); + Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", builder, nextLineProvider)); + + var dbc = builder.Build(); + Assert.AreEqual(100, dbc.Messages.First().CycleTime); + } + + [Test] + public void SigCustomPropertyIsParsed() + { + var builder = new DbcBuilder(); + var message = new Message { ID = 2394947585 }; + message.IsExtID = DbcBuilder.IsExtID(ref message.ID); + builder.AddMessage(message); + var signal = new Signal { Name = "sig_name" }; + builder.AddSignal(signal); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_ SG_ ""GenSigStartValue"" INT 0 200;", builder, nextLineProvider)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_DEF_ ""GenSigStartValue"" 150;", builder, nextLineProvider)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", builder, nextLineProvider)); + + var dbc = builder.Build(); + Assert.AreEqual(40, dbc.Messages.First().Signals.First().InitialValue); + } + + [Test] + public void NodeCustomPropertyIsParsed() + { + var builder = new DbcBuilder(); + var node = new Node { Name = "Node1" }; + builder.AddNode(node); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_ BU_ ""AttributeName"" HEX 0 200;", builder, nextLineProvider)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_DEF_ ""AttributeName"" 150;", builder, nextLineProvider)); + Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_ ""AttributeName"" BU_ Node1 40;", builder, nextLineProvider)); + } } } \ No newline at end of file diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index 34f745d..054f194 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -19,7 +19,11 @@ public class DbcBuilder : IDbcBuilder private readonly IDictionary m_namedTablesMap = new Dictionary(); private readonly IDictionary m_messages = new Dictionary(); private readonly IDictionary> m_signals = new Dictionary>(); - private readonly IDictionary> m_customProperties = new Dictionary>(); + private readonly IDictionary> m_customProperties = new Dictionary>() { + {DbcObjectType.Node, new Dictionary()}, + {DbcObjectType.Message, new Dictionary()}, + {DbcObjectType.Signal, new Dictionary()}, + }; private Message m_currentMessage; @@ -77,19 +81,20 @@ public void AddMessageCustomProperty(string propertyName, uint messageId, string { if (m_customProperties[DbcObjectType.Message].TryGetValue(propertyName, out var customProperty)) { + IsExtID(ref messageId); if (m_messages.TryGetValue(messageId, out var message)) { SetCustomPropertyValue(customProperty, value); message.CustomProperties[propertyName] = customProperty; } - } } public void AddSignalCustomProperty(string propertyName, uint messageId, string signalName, string value) { - if (m_customProperties[DbcObjectType.Message].TryGetValue(propertyName, out var customProperty)) + if (m_customProperties[DbcObjectType.Signal].TryGetValue(propertyName, out var customProperty)) { + IsExtID(ref messageId); if (TryGetValueMessageSignal(messageId, signalName, out var signal)) { SetCustomPropertyValue(customProperty, value); diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index 993715f..321bd1b 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -8,12 +8,12 @@ namespace DbcParserLib.Parsers { public class PropertiesLineParser : ILineParser { - private const string PropertiesLineStarter = "BA_ "; - private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; - private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; - private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"");"; + private const string PropertiesLineStarter = "BA_"; + private const string PropertiesDefinitionLineStarter = "BA_DEF_"; + private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_"; + private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(-?\d+|[0-9.]+|""[^""]*"");"; private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9.]+)\s+([0-9.]+))|(STRING)|(?:(ENUM)\s+""([^""]*)""))\s*;"; - private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(?:(-?\d+|[0-9.]+)|""([^""]*)"")\s*;"; + private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(-?\d+|[0-9.]+|""[^""]*"")\s*;"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { @@ -101,19 +101,19 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin var match = Regex.Match(cleanLine, PropertyParsingRegex); if (match.Success) { - if (match.Groups[4].Value == "BU_") - builder.AddNodeCustomProperty(match.Groups[1].Value, match.Groups[5].Value, match.Groups[6].Value); - if (match.Groups[4].Value == "BO_") + if (match.Groups[2].Value == "BU_") + builder.AddNodeCustomProperty(match.Groups[1].Value, match.Groups[3].Value, match.Groups[9].Value); + else if (match.Groups[4].Value == "BO_") { - builder.AddMessageCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[10].Value, CultureInfo.InvariantCulture), match.Groups[3].Value); + builder.AddMessageCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), match.Groups[9].Value); if (match.Groups[1].Value == "GenMsgCycleTime") - builder.AddMessageCycleTime(uint.Parse(match.Groups[10].Value, CultureInfo.InvariantCulture), int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture)); + builder.AddMessageCycleTime(uint.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), int.Parse(match.Groups[9].Value, CultureInfo.InvariantCulture)); } - if (match.Groups[4].Value == "SG_") + else if (match.Groups[6].Value == "SG_") { - builder.AddSignalCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[15].Value, CultureInfo.InvariantCulture), match.Groups[16].Value, match.Groups[17].Value); + builder.AddSignalCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), match.Groups[8].Value, match.Groups[9].Value); if (match.Groups[1].Value == "GenSigStartValue") - builder.AddSignalInitialValue(uint.Parse(match.Groups[15].Value, CultureInfo.InvariantCulture), match.Groups[16].Value, double.Parse(match.Groups[17].Value, CultureInfo.InvariantCulture)); + builder.AddSignalInitialValue(uint.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), match.Groups[8].Value, double.Parse(match.Groups[9].Value, CultureInfo.InvariantCulture)); } } return true; From 2798b47c31c440f5eed2b227d1ce1794086f83bc Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Tue, 21 Feb 2023 13:16:57 +0100 Subject: [PATCH 4/9] New classes, Regex improvement, Code refactoring - HexCustomProperty class merged into IntCustomProperty class - PropertyLineParser classe splitted into different files - Different classes for property definition and property assignment - Improved regex for enum parsing - Added some tests --- .../PropertiesLineParserTests.cs | 51 ++++++--- DbcParserLib/DbcBuilder.cs | 105 ++++-------------- DbcParserLib/IDbcBuilder.cs | 2 +- DbcParserLib/Model/CustomProperty.cs | 99 +++++++++++++++++ .../Model/CustomPropertyDefinition.cs | 72 ++++++++++++ DbcParserLib/Model/Node.cs | 56 ---------- DbcParserLib/Parser.cs | 1 + .../Parsers/PropertiesDefinitionLineParser.cs | 92 +++++++++++++++ DbcParserLib/Parsers/PropertiesLineParser.cs | 86 +------------- 9 files changed, 328 insertions(+), 236 deletions(-) create mode 100644 DbcParserLib/Model/CustomProperty.cs create mode 100644 DbcParserLib/Model/CustomPropertyDefinition.cs create mode 100644 DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs diff --git a/DbcParserLib.Tests/PropertiesLineParserTests.cs b/DbcParserLib.Tests/PropertiesLineParserTests.cs index f93a43c..d27fbb7 100644 --- a/DbcParserLib.Tests/PropertiesLineParserTests.cs +++ b/DbcParserLib.Tests/PropertiesLineParserTests.cs @@ -4,14 +4,28 @@ using Moq; using System.Linq; using System.IO; +using System.Collections.Generic; namespace DbcParserLib.Tests { public class PropertiesLineParserTests { - private static ILineParser CreateParser() + private static List CreateParser() { - return new PropertiesLineParser(); + return new List() { + new PropertiesLineParser(), + new PropertiesDefinitionLineParser() + }; + } + + private static bool ParseLine(string line, List lineParser, IDbcBuilder builder, INextLineProvider nextLineProvider) + { + foreach (var parser in lineParser) + { + if (parser.TryParse(line, builder, nextLineProvider)) + return true; + } + return false; } [Test] @@ -24,7 +38,7 @@ public void MsgCycleTimeIsParsed() var msgCycleTimeLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", msgCycleTimeLineParser, builder, nextLineProvider)); var dbc = builder.Build(); Assert.AreEqual(100, dbc.Messages.First().CycleTime); @@ -42,7 +56,7 @@ public void SigInitalValueIsParsed() var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", sigInitialValueLineParser, builder, nextLineProvider)); var dbc = builder.Build(); Assert.AreEqual(40, dbc.Messages.First().Signals.First().InitialValue); @@ -58,9 +72,9 @@ public void MsgCustomPropertyIsParsed() var msgCycleTimeLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_DEF_ BO_ ""GenMsgCycleTime"" INT 0 200;", builder, nextLineProvider)); - Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_DEF_DEF_ ""GenMsgCycleTime"" 150;", builder, nextLineProvider)); - Assert.IsTrue(msgCycleTimeLineParser.TryParse(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BO_ ""GenMsgCycleTime"" INT 0 200;", msgCycleTimeLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""GenMsgCycleTime"" 150;", msgCycleTimeLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", msgCycleTimeLineParser, builder, nextLineProvider)); var dbc = builder.Build(); Assert.AreEqual(100, dbc.Messages.First().CycleTime); @@ -78,9 +92,9 @@ public void SigCustomPropertyIsParsed() var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_ SG_ ""GenSigStartValue"" INT 0 200;", builder, nextLineProvider)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_DEF_ ""GenSigStartValue"" 150;", builder, nextLineProvider)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ SG_ ""GenSigStartValue"" INT 0 200;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""GenSigStartValue"" 150;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", sigInitialValueLineParser, builder, nextLineProvider)); var dbc = builder.Build(); Assert.AreEqual(40, dbc.Messages.First().Signals.First().InitialValue); @@ -95,9 +109,20 @@ public void NodeCustomPropertyIsParsed() var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_ BU_ ""AttributeName"" HEX 0 200;", builder, nextLineProvider)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_DEF_DEF_ ""AttributeName"" 150;", builder, nextLineProvider)); - Assert.IsTrue(sigInitialValueLineParser.TryParse(@"BA_ ""AttributeName"" BU_ Node1 40;", builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" HEX 0 200;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 150;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""AttributeName"" BU_ Node1 40;", sigInitialValueLineParser, builder, nextLineProvider)); + } + + [Test] + public void EnumDefinitionCustomPropertyIsParsed() + { + var builder = new DbcBuilder(); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" ENUM ""Ciao"",""Mamma"",""Guarda"";", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" ""Guarda"";", sigInitialValueLineParser, builder, nextLineProvider)); } } } \ No newline at end of file diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index 054f194..6991c0e 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -19,10 +19,10 @@ public class DbcBuilder : IDbcBuilder private readonly IDictionary m_namedTablesMap = new Dictionary(); private readonly IDictionary m_messages = new Dictionary(); private readonly IDictionary> m_signals = new Dictionary>(); - private readonly IDictionary> m_customProperties = new Dictionary>() { - {DbcObjectType.Node, new Dictionary()}, - {DbcObjectType.Message, new Dictionary()}, - {DbcObjectType.Signal, new Dictionary()}, + private readonly IDictionary> m_customProperties = new Dictionary>() { + {DbcObjectType.Node, new Dictionary()}, + {DbcObjectType.Message, new Dictionary()}, + {DbcObjectType.Signal, new Dictionary()}, }; private Message m_currentMessage; @@ -48,7 +48,7 @@ public void AddSignal(Signal signal) } } - public void AddCustomProperty(DbcObjectType objectType, CustomProperty customProperty) + public void AddCustomProperty(DbcObjectType objectType, CustomPropertyDefinition customProperty) { m_customProperties[objectType][customProperty.Name] = customProperty; } @@ -59,7 +59,7 @@ public void AddCustomPropertyDefaultValue(string propertyName, string value) { if (m_customProperties[objectType].TryGetValue(propertyName, out var customProperty)) { - SetCustomPropertyDefaultValue(customProperty, value); + customProperty.SetCustomPropertyDefaultValue(value); } } } @@ -71,8 +71,9 @@ public void AddNodeCustomProperty(string propertyName, string nodeName, string v var node = m_nodes.FirstOrDefault(n => n.Name.Equals(nodeName)); if (node != null) { - SetCustomPropertyValue(customProperty, value); - node.CustomProperties[propertyName] = customProperty; + var property = new CustomProperty(customProperty); + property.SetCustomPropertyValue(value); + node.CustomProperties[propertyName] = property; } } } @@ -84,8 +85,9 @@ public void AddMessageCustomProperty(string propertyName, uint messageId, string IsExtID(ref messageId); if (m_messages.TryGetValue(messageId, out var message)) { - SetCustomPropertyValue(customProperty, value); - message.CustomProperties[propertyName] = customProperty; + var property = new CustomProperty(customProperty); + property.SetCustomPropertyValue(value); + message.CustomProperties[propertyName] = property; } } } @@ -97,8 +99,9 @@ public void AddSignalCustomProperty(string propertyName, uint messageId, string IsExtID(ref messageId); if (TryGetValueMessageSignal(messageId, signalName, out var signal)) { - SetCustomPropertyValue(customProperty, value); - signal.CustomProperties[propertyName] = customProperty; + var property = new CustomProperty(customProperty); + property.SetCustomPropertyValue(value); + signal.CustomProperties[propertyName] = property; } } } @@ -203,72 +206,6 @@ private bool TryGetValueMessageSignal(uint messageId, string signalName, out Sig return false; } - private void SetCustomPropertyValue(CustomProperty customProperty, string value) - { - switch (customProperty.DataType) - { - case DbcDataType.Integer: - customProperty.IntegerCustomProperty.Value = int.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.Hex: - customProperty.HexCustomProperty.Value = int.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.Float: - customProperty.FloatCustomProperty.Value = float.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.String: - customProperty.StringCustomProperty.Value = value; - break; - case DbcDataType.Enum: - customProperty.EnumCustomProperty.Value = value.Split(','); - break; - } - } - - private void SetCustomPropertyDefaultValue(CustomProperty customProperty, string value) - { - switch (customProperty.DataType) - { - case DbcDataType.Integer: - customProperty.IntegerCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.Hex: - customProperty.HexCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.Float: - customProperty.FloatCustomProperty.Default = float.Parse(value, CultureInfo.InvariantCulture); - break; - case DbcDataType.String: - customProperty.StringCustomProperty.Default = value; - break; - case DbcDataType.Enum: - customProperty.EnumCustomProperty.Default = value.Split(','); - break; - } - } - - private void SetCustomPropertyValueFromDefault(CustomProperty customProperty) - { - switch (customProperty.DataType) - { - case DbcDataType.Integer: - customProperty.IntegerCustomProperty.Value = customProperty.IntegerCustomProperty.Default; - break; - case DbcDataType.Hex: - customProperty.HexCustomProperty.Value = customProperty.HexCustomProperty.Default; - break; - case DbcDataType.Float: - customProperty.FloatCustomProperty.Value = customProperty.FloatCustomProperty.Default; - break; - case DbcDataType.String: - customProperty.StringCustomProperty.Value = customProperty.StringCustomProperty.Default; - break; - case DbcDataType.Enum: - customProperty.EnumCustomProperty.Value = customProperty.EnumCustomProperty.Default; - break; - } - } - private void FillNodesNotSetCustomPropertyWithDefault() { var nodeCustomProperties = m_customProperties[DbcObjectType.Node]; @@ -278,8 +215,8 @@ private void FillNodesNotSetCustomPropertyWithDefault() { if (!node.CustomProperties.TryGetValue(customProperty.Key, out var property)) { - SetCustomPropertyValueFromDefault(property); - node.CustomProperties[property.Name] = property; + node.CustomProperties[customProperty.Key] = new CustomProperty(customProperty.Value); + node.CustomProperties[customProperty.Key].SetCustomPropertyValueFromDefault(); } } } @@ -295,8 +232,8 @@ private void FillMesagesNotSetCustomPropertyWithDefault() FillSignalsNotSetCustomPropertyWithDefault(message.ID); if (!message.CustomProperties.TryGetValue(customProperty.Key, out var property)) { - SetCustomPropertyValueFromDefault(property); - message.CustomProperties[property.Name] = property; + message.CustomProperties[customProperty.Key] = new CustomProperty(customProperty.Value); + message.CustomProperties[customProperty.Key].SetCustomPropertyValueFromDefault(); } } } @@ -311,8 +248,8 @@ private void FillSignalsNotSetCustomPropertyWithDefault(uint messageId) { if (!signal.CustomProperties.TryGetValue(customProperty.Key, out var property)) { - SetCustomPropertyValueFromDefault(property); - signal.CustomProperties[property.Name] = property; + signal.CustomProperties[customProperty.Key] = new CustomProperty(customProperty.Value); + signal.CustomProperties[customProperty.Key].SetCustomPropertyValueFromDefault(); } } } diff --git a/DbcParserLib/IDbcBuilder.cs b/DbcParserLib/IDbcBuilder.cs index 531ec4f..266df3b 100644 --- a/DbcParserLib/IDbcBuilder.cs +++ b/DbcParserLib/IDbcBuilder.cs @@ -17,7 +17,7 @@ public interface IDbcBuilder void AddSignalValueType(uint messageId, string signalName, DbcValueType valueType); void LinkNamedTableToSignal(uint messageId, string signalName, string tableName); void LinkTableValuesToSignal(uint messageId, string signalName, IReadOnlyDictionary dictValues, string stringValues); - void AddCustomProperty(DbcObjectType objectType, CustomProperty customProperty); + void AddCustomProperty(DbcObjectType objectType, CustomPropertyDefinition customProperty); void AddCustomPropertyDefaultValue(string propertyName, string value); void AddNodeCustomProperty(string propertyName, string nodeName, string value); void AddMessageCustomProperty(string propertyName, uint messageId, string value); diff --git a/DbcParserLib/Model/CustomProperty.cs b/DbcParserLib/Model/CustomProperty.cs new file mode 100644 index 0000000..a0456b7 --- /dev/null +++ b/DbcParserLib/Model/CustomProperty.cs @@ -0,0 +1,99 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Text; + +namespace DbcParserLib.Model +{ + public class CustomProperty + { + private CustomPropertyDefinition m_customPropertyDefinition; + + public CustomProperty(CustomPropertyDefinition customPropertyDefinition) + { + m_customPropertyDefinition = customPropertyDefinition; + } + + public IntegerCustomProperty IntegerCustomProperty { get; set; } + public FloatCustomProperty FloatCustomProperty { get; set; } + public StringCustomProperty StringCustomProperty { get; set; } + + public void SetCustomPropertyValue(string value) + { + switch (m_customPropertyDefinition.DataType) + { + case DbcDataType.Integer: + IntegerCustomProperty = new IntegerCustomProperty() + { + Value = int.Parse(value, CultureInfo.InvariantCulture) + }; + break; + case DbcDataType.Float: + FloatCustomProperty = new FloatCustomProperty() + { + Value = float.Parse(value, CultureInfo.InvariantCulture) + }; + break; + case DbcDataType.String: + StringCustomProperty = new StringCustomProperty() + { + Value = value + }; + break; + case DbcDataType.Enum: + if(m_customPropertyDefinition.EnumCustomProperty.Definition.Contains(value)) + StringCustomProperty = new StringCustomProperty() + { + Value = value + }; + break; + } + } + + public void SetCustomPropertyValueFromDefault() + { + switch (m_customPropertyDefinition.DataType) + { + case DbcDataType.Integer: + IntegerCustomProperty = new IntegerCustomProperty() + { + Value = m_customPropertyDefinition.IntegerCustomProperty.Default + }; + break; + case DbcDataType.Float: + FloatCustomProperty = new FloatCustomProperty() + { + Value = m_customPropertyDefinition.FloatCustomProperty.Default + }; + break; + case DbcDataType.String: + StringCustomProperty = new StringCustomProperty() + { + Value = m_customPropertyDefinition.StringCustomProperty.Default + }; + break; + case DbcDataType.Enum: + StringCustomProperty = new StringCustomProperty() + { + Value = m_customPropertyDefinition.EnumCustomProperty.Default + }; + break; + } + } + } + + public class IntegerCustomProperty + { + public int Value { get; set; } + } + + public class FloatCustomProperty + { + public double Value { get; set; } + } + public class StringCustomProperty + { + public string Value { get; set; } + } +} diff --git a/DbcParserLib/Model/CustomPropertyDefinition.cs b/DbcParserLib/Model/CustomPropertyDefinition.cs new file mode 100644 index 0000000..a48b9c1 --- /dev/null +++ b/DbcParserLib/Model/CustomPropertyDefinition.cs @@ -0,0 +1,72 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Text; + +namespace DbcParserLib.Model +{ + public class CustomPropertyDefinition + { + public string Name { get; set; } + public DbcDataType DataType { get; set; } + public IntegerCustomPropertyDefinition IntegerCustomProperty { get; set; } + public FloatCustomPropertyDefinition FloatCustomProperty { get; set; } + public StringCustomPropertyDefinition StringCustomProperty { get; set; } + public EnumCustomPropertyDefinition EnumCustomProperty { get; set; } + + public void SetCustomPropertyDefaultValue(string value) + { + switch (DataType) + { + case DbcDataType.Integer: + IntegerCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.Float: + FloatCustomProperty.Default = float.Parse(value, CultureInfo.InvariantCulture); + break; + case DbcDataType.String: + StringCustomProperty.Default = value; + break; + case DbcDataType.Enum: + if (EnumCustomProperty.Definition.Contains(value)) + EnumCustomProperty.Default = value; + break; + } + } + } + + public class IntegerCustomPropertyDefinition + { + public int Maximum { get; set; } + public int Minimum { get; set; } + public int Default { get; set; } + } + + public class FloatCustomPropertyDefinition + { + public double Maximum { get; set; } + public double Minimum { get; set; } + public double Default { get; set; } + } + public class StringCustomPropertyDefinition + { + public string Default { get; set; } + } + + public class EnumCustomPropertyDefinition + { + public string Default { get; set; } + public string[] Definition { get; set; } + } + + public enum DbcObjectType + { + Node, Message, Signal, Environment + } + + public enum DbcDataType + { + Integer, Float, String, Enum + } +} diff --git a/DbcParserLib/Model/Node.cs b/DbcParserLib/Model/Node.cs index 2a713c5..7b78b24 100644 --- a/DbcParserLib/Model/Node.cs +++ b/DbcParserLib/Model/Node.cs @@ -68,62 +68,6 @@ internal void SetValueTable(IReadOnlyDictionary dictValues, string } } - public class CustomProperty - { - public string Name { get; set; } - public DbcDataType DataType { get; set; } - public IntegerCustomProperty IntegerCustomProperty { get; set; } - public HexCustomProperty HexCustomProperty { get; set; } - public FloatCustomProperty FloatCustomProperty { get; set; } - public StringCustomProperty StringCustomProperty { get; set; } - public EnumCustomProperty EnumCustomProperty { get; set; } - } - - public class IntegerCustomProperty - { - public int Maximum { get; set; } - public int Minimum { get; set; } - public int Default { get; set; } - public int Value { get; set; } - } - - public class HexCustomProperty - { - public int Maximum { get; set; } - public int Minimum { get; set; } - public int Default { get; set; } - public int Value { get; set; } - } - - public class FloatCustomProperty - { - public double Maximum { get; set; } - public double Minimum { get; set; } - public double Default { get; set; } - public double Value { get; set; } - } - public class StringCustomProperty - { - public string Default { get; set; } - public string Value { get; set; } - } - - public class EnumCustomProperty - { - public string[] Default { get; set; } - public string[] Value { get; set; } - } - - public enum DbcObjectType - { - Node, Message, Signal, Environment - } - - public enum DbcDataType - { - Integer, Hex, Float, String, Enum - } - public enum DbcValueType { Signed, Unsigned, IEEEFloat, IEEEDouble diff --git a/DbcParserLib/Parser.cs b/DbcParserLib/Parser.cs index 520b2e9..5dd51bb 100644 --- a/DbcParserLib/Parser.cs +++ b/DbcParserLib/Parser.cs @@ -18,6 +18,7 @@ public static class Parser new SignalValueTypeLineParser(), new ValueTableLineParser(), new PropertiesLineParser(), + new PropertiesDefinitionLineParser(), new UnknownLineParser() // Used as a catch all }; diff --git a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs new file mode 100644 index 0000000..b3d2a59 --- /dev/null +++ b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs @@ -0,0 +1,92 @@ +using DbcParserLib.Model; +using System; +using System.Globalization; +using System.Linq; +using System.Text.RegularExpressions; + +namespace DbcParserLib.Parsers +{ + public class PropertiesDefinitionLineParser : ILineParser + { + private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; + private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; + private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9.]+)\s+([0-9.]+))|(STRING)|(ENUM\s+(?:""[^""]*"",*){1,100}))\s*;"; + private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(-?\d+|[0-9.]+|""[^""]*"")\s*;"; + + public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) + { + var cleanLine = line.Trim(' '); + + if (cleanLine.StartsWith(PropertiesDefinitionLineStarter) == false + && cleanLine.StartsWith(PropertiesDefinitionDefaultLineStarter) == false) + return false; + + if (cleanLine.StartsWith(PropertiesDefinitionDefaultLineStarter)) + { + var match = Regex.Match(cleanLine, PropertyDefinitionDefaultParsingRegex); + if (match.Success) + { + builder.AddCustomPropertyDefaultValue(match.Groups[1].Value, match.Groups[2].Value.Replace("\"", "")); + } + return true; + } + + if (cleanLine.StartsWith(PropertiesDefinitionLineStarter)) + { + var match = Regex.Match(cleanLine, PropertyDefinitionParsingRegex); + if (match.Success) + { + var customProperty = new CustomPropertyDefinition + { + Name = match.Groups[2].Value, + }; + + DbcObjectType objectType = DbcObjectType.Node; + switch (match.Groups[1].Value) + { + case "BO_": + objectType = DbcObjectType.Message; break; + case "SG_": + objectType = DbcObjectType.Signal; break; + case "EV_": + objectType = DbcObjectType.Environment; break; + } + + DbcDataType dataType = DbcDataType.Integer; + if (match.Groups[3].Value == "INT" || match.Groups[3].Value == "HEX") + { + customProperty.IntegerCustomProperty = new IntegerCustomPropertyDefinition + { + Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), + Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), + }; + } + else if (match.Groups[6].Value == "FLOAT") + { + dataType = DbcDataType.Float; + customProperty.FloatCustomProperty = new FloatCustomPropertyDefinition + { + Minimum = double.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), + Maximum = double.Parse(match.Groups[8].Value, CultureInfo.InvariantCulture), + }; + } + else if (match.Groups[9].Value == "STRING") + dataType = DbcDataType.String; + else if (match.Groups[10].Value.StartsWith("ENUM ")) + { + dataType = DbcDataType.Enum; + var enumDefinition = match.Groups[10].Value.Replace("\"", "").Split(' ')[1]; + customProperty.EnumCustomProperty = new EnumCustomPropertyDefinition + { + Definition = enumDefinition.Split(','), + }; + } + customProperty.DataType = dataType; + builder.AddCustomProperty(objectType, customProperty); + } + return true; + } + return false; + } + } +} \ No newline at end of file diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index 321bd1b..9922f4a 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -8,12 +8,8 @@ namespace DbcParserLib.Parsers { public class PropertiesLineParser : ILineParser { - private const string PropertiesLineStarter = "BA_"; - private const string PropertiesDefinitionLineStarter = "BA_DEF_"; - private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_"; + private const string PropertiesLineStarter = "BA_ "; private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(-?\d+|[0-9.]+|""[^""]*"");"; - private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9.]+)\s+([0-9.]+))|(STRING)|(?:(ENUM)\s+""([^""]*)""))\s*;"; - private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(-?\d+|[0-9.]+|""[^""]*"")\s*;"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { @@ -22,96 +18,22 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin if (cleanLine.StartsWith(PropertiesLineStarter) == false) return false; - if (cleanLine.StartsWith(PropertiesDefinitionDefaultLineStarter)) - { - var match = Regex.Match(cleanLine, PropertyDefinitionDefaultParsingRegex); - if (match.Success) - { - builder.AddCustomPropertyDefaultValue(match.Groups[1].Value, match.Groups[2].Value); - } - return true; - } - - if (cleanLine.StartsWith(PropertiesDefinitionLineStarter)) - { - var match = Regex.Match(cleanLine, PropertyDefinitionParsingRegex); - if (match.Success) - { - var customProperty = new CustomProperty - { - Name = match.Groups[2].Value, - }; - - DbcObjectType objectType = DbcObjectType.Node; - switch (match.Groups[1].Value) - { - case "BO_": - objectType = DbcObjectType.Message; break; - case "SG_": - objectType = DbcObjectType.Signal; break; - case "EV_": - objectType = DbcObjectType.Environment; break; - } - - DbcDataType dataType = DbcDataType.Integer; - if (match.Groups[3].Value == "INT") - { - customProperty.IntegerCustomProperty = new IntegerCustomProperty - { - Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), - Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), - }; - } - else if (match.Groups[3].Value == "HEX") - { - dataType = DbcDataType.Hex; - customProperty.HexCustomProperty = new HexCustomProperty - { - Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), - Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), - }; - } - else if (match.Groups[6].Value == "FLOAT") - { - dataType = DbcDataType.Float; - customProperty.FloatCustomProperty = new FloatCustomProperty - { - Minimum = double.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), - Maximum = double.Parse(match.Groups[8].Value, CultureInfo.InvariantCulture), - }; - } - else if(match.Groups[9].Value == "STRING") - dataType = DbcDataType.String; - else if (match.Groups[10].Value == "ENUM") - { - dataType = DbcDataType.Enum; - customProperty.EnumCustomProperty = new EnumCustomProperty - { - Default = match.Groups[11].Value.Split(','), - }; - } - customProperty.DataType = dataType; - builder.AddCustomProperty(objectType, customProperty); - } - return true; - } - if (cleanLine.StartsWith(PropertiesLineStarter)) { var match = Regex.Match(cleanLine, PropertyParsingRegex); if (match.Success) { if (match.Groups[2].Value == "BU_") - builder.AddNodeCustomProperty(match.Groups[1].Value, match.Groups[3].Value, match.Groups[9].Value); + builder.AddNodeCustomProperty(match.Groups[1].Value, match.Groups[3].Value, match.Groups[9].Value.Replace("\"", "")); else if (match.Groups[4].Value == "BO_") { - builder.AddMessageCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), match.Groups[9].Value); + builder.AddMessageCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), match.Groups[9].Value.Replace("\"", "")); if (match.Groups[1].Value == "GenMsgCycleTime") builder.AddMessageCycleTime(uint.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), int.Parse(match.Groups[9].Value, CultureInfo.InvariantCulture)); } else if (match.Groups[6].Value == "SG_") { - builder.AddSignalCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), match.Groups[8].Value, match.Groups[9].Value); + builder.AddSignalCustomProperty(match.Groups[1].Value, uint.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), match.Groups[8].Value, match.Groups[9].Value.Replace("\"", "")); if (match.Groups[1].Value == "GenSigStartValue") builder.AddSignalInitialValue(uint.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), match.Groups[8].Value, double.Parse(match.Groups[9].Value, CultureInfo.InvariantCulture)); } From 067387f9e53c60631263a88b94043f548e6bdf64 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Tue, 21 Feb 2023 16:11:24 +0100 Subject: [PATCH 5/9] Added tests Added custom property tests --- DbcParserLib.Tests/ParserTests.cs | 48 ++++++++++ .../PropertiesLineParserTests.cs | 91 ++++++++++++++----- DbcParserLib/Model/CustomProperty.cs | 9 +- .../Model/CustomPropertyDefinition.cs | 3 +- .../Parsers/PropertiesDefinitionLineParser.cs | 3 + 5 files changed, 123 insertions(+), 31 deletions(-) diff --git a/DbcParserLib.Tests/ParserTests.cs b/DbcParserLib.Tests/ParserTests.cs index c248be8..cdfe2d8 100644 --- a/DbcParserLib.Tests/ParserTests.cs +++ b/DbcParserLib.Tests/ParserTests.cs @@ -282,5 +282,53 @@ public void ExplicitValTableIsAppliedTest() Assert.IsNotNull(signal); Assert.AreEqual(107, signal.ValueTable.Length); } + + [Test] + public void UserDefinedAttributesTest() + { + // This example is taken from kia_ev6.dbc + var dbcString = @" +BU_: XXX + +BO_ 1043 BLINKERS: 8 XXX + SG_ COUNTER_ALT : 15|4@0+ (1,0) [0|15] """" XXX + SG_ LEFT_LAMP : 20|1@0+ (1,0) [0|1] """" XXX + SG_ RIGHT_LAMP : 22|1@0+ (1,0) [0|1] """" XXX + +BA_DEF_ BU_ ""HexAttribute"" HEX 0 100; +BA_DEF_ BO_ ""IntegerAttribute"" INT 0 10; +BA_DEF_ BO_ ""FloatAttribute"" FLOAT 0 1; +BA_DEF_ SG_ ""StringAttribute"" STRING; +BA_DEF_ SG_ ""EnumAttributeName"" ENUM ""FirstVal"",""SecondVal"",""ThirdVal""; + +BA_DEF_DEF_ ""HexAttribute"" 50; +BA_DEF_DEF_ ""IntegerAttribute"" 5; +BA_DEF_DEF_ ""FloatAttribute"" 0.5; +BA_DEF_DEF_ ""StringAttribute"" ""DefaultString""; +BA_DEF_DEF_ ""EnumAttributeName"" ""FirstVal""; + +BA_ ""HexAttribute"" BU_ XXX 70; +BA_ ""IntegerAttribute"" BO_ 1043 7; +BA_ ""EnumAttributeName"" SG_ 1043 COUNTER_ALT ""ThirdVal""; "; + + var dbc = Parser.Parse(dbcString); + Assert.AreEqual(1, dbc.Messages.Count()); + Assert.AreEqual(1, dbc.Nodes.Count()); + + var node = dbc.Nodes.First(); + Assert.AreEqual(1, node.CustomProperties.Count()); + Assert.AreEqual(70, node.CustomProperties["HexAttribute"].IntegerCustomProperty.Value); + + var message = dbc.Messages.First(); + Assert.AreEqual(2, message.CustomProperties.Count()); + Assert.AreEqual(7, message.CustomProperties["IntegerAttribute"].IntegerCustomProperty.Value); + Assert.AreEqual(0.5, message.CustomProperties["FloatAttribute"].FloatCustomProperty.Value); + + var signal = dbc.Messages.Single().Signals.FirstOrDefault(x => x.Name.Equals("COUNTER_ALT")); + Assert.IsNotNull(signal); + Assert.AreEqual(2, signal.CustomProperties.Count()); + Assert.AreEqual("ThirdVal", signal.CustomProperties["EnumAttributeName"].StringCustomProperty.Value); + Assert.AreEqual("DefaultString", signal.CustomProperties["StringAttribute"].StringCustomProperty.Value); + } } } \ No newline at end of file diff --git a/DbcParserLib.Tests/PropertiesLineParserTests.cs b/DbcParserLib.Tests/PropertiesLineParserTests.cs index d27fbb7..63fa2d9 100644 --- a/DbcParserLib.Tests/PropertiesLineParserTests.cs +++ b/DbcParserLib.Tests/PropertiesLineParserTests.cs @@ -29,41 +29,51 @@ private static bool ParseLine(string line, List lineParser, IDbcBui } [Test] - public void MsgCycleTimeIsParsed() + public void IntDefinitionCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new Message { ID = 2394947585 }; - message.IsExtID = DbcBuilder.IsExtID(ref message.ID); - builder.AddMessage(message); - var msgCycleTimeLineParser = CreateParser(); + var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(ParseLine(@"BA_ ""GenMsgCycleTime"" BO_ 2394947585 100;", msgCycleTimeLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" INT 5 10;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 7;", sigInitialValueLineParser, builder, nextLineProvider)); + } - var dbc = builder.Build(); - Assert.AreEqual(100, dbc.Messages.First().CycleTime); + [Test] + public void FloatDefinitionCustomPropertyIsParsedTest() + { + var builder = new DbcBuilder(); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" FLOAT 5 10.5;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 7.5;", sigInitialValueLineParser, builder, nextLineProvider)); } [Test] - public void SigInitalValueIsParsed() + public void StringDefinitionCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new Message { ID = 2394947585 }; - message.IsExtID = DbcBuilder.IsExtID(ref message.ID); - builder.AddMessage(message); - var signal = new Signal { Name = "sig_name" }; - builder.AddSignal(signal); var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(ParseLine(@"BA_ ""GenSigStartValue"" SG_ 2394947585 sig_name 40;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" STRING;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" ""DefaultString"";", sigInitialValueLineParser, builder, nextLineProvider)); + } - var dbc = builder.Build(); - Assert.AreEqual(40, dbc.Messages.First().Signals.First().InitialValue); + [Test] + public void EnumDefinitionCustomPropertyIsParsedTest() + { + var builder = new DbcBuilder(); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" ENUM ""Val1"",""Val2"",""Val3"";", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" ""Val2"";", sigInitialValueLineParser, builder, nextLineProvider)); } [Test] - public void MsgCustomPropertyIsParsed() + public void MsgCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); var message = new Message { ID = 2394947585 }; @@ -81,7 +91,7 @@ public void MsgCustomPropertyIsParsed() } [Test] - public void SigCustomPropertyIsParsed() + public void SigCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); var message = new Message { ID = 2394947585 }; @@ -101,7 +111,7 @@ public void SigCustomPropertyIsParsed() } [Test] - public void NodeCustomPropertyIsParsed() + public void NodeCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); var node = new Node { Name = "Node1" }; @@ -115,14 +125,47 @@ public void NodeCustomPropertyIsParsed() } [Test] - public void EnumDefinitionCustomPropertyIsParsed() + public void NodeMultipleCustomPropertyAreParsedTest() + { + var builder = new DbcBuilder(); + var node = new Node { Name = "Node1" }; + builder.AddNode(node); + + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName1"" INT 0 200;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName1"" 100;", sigInitialValueLineParser, builder, nextLineProvider)); + + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName2"" FLOAT 0 10;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName2"" 5.5;", sigInitialValueLineParser, builder, nextLineProvider)); + + Assert.IsTrue(ParseLine(@"BA_ ""AttributeName1"" BU_ Node1 40;", sigInitialValueLineParser, builder, nextLineProvider)); + + var dbc = builder.Build(); + Assert.AreEqual(2, dbc.Nodes.First().CustomProperties.Count); + Assert.AreEqual(5.5, dbc.Nodes.First().CustomProperties["AttributeName2"].FloatCustomProperty.Value); + } + + [Test] + public void CustomPropertyIsAssignedToDifferentNodesTest() { var builder = new DbcBuilder(); - + var node1 = new Node { Name = "Node1" }; + var node2 = new Node { Name = "Node2" }; + builder.AddNode(node1); + builder.AddNode(node2); + var sigInitialValueLineParser = CreateParser(); var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); - Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" ENUM ""Ciao"",""Mamma"",""Guarda"";", sigInitialValueLineParser, builder, nextLineProvider)); - Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" ""Guarda"";", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" INT 0 200;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 100;", sigInitialValueLineParser, builder, nextLineProvider)); + + Assert.IsTrue(ParseLine(@"BA_ ""AttributeName"" BU_ Node1 40;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""AttributeName"" BU_ Node2 70;", sigInitialValueLineParser, builder, nextLineProvider)); + + var dbc = builder.Build(); + Assert.AreEqual(40, dbc.Nodes.First().CustomProperties["AttributeName"].IntegerCustomProperty.Value); + Assert.AreEqual(70, dbc.Nodes.ElementAt(1).CustomProperties["AttributeName"].IntegerCustomProperty.Value); } } } \ No newline at end of file diff --git a/DbcParserLib/Model/CustomProperty.cs b/DbcParserLib/Model/CustomProperty.cs index a0456b7..3f47107 100644 --- a/DbcParserLib/Model/CustomProperty.cs +++ b/DbcParserLib/Model/CustomProperty.cs @@ -42,11 +42,10 @@ public void SetCustomPropertyValue(string value) }; break; case DbcDataType.Enum: - if(m_customPropertyDefinition.EnumCustomProperty.Definition.Contains(value)) - StringCustomProperty = new StringCustomProperty() - { - Value = value - }; + StringCustomProperty = new StringCustomProperty() + { + Value = value + }; break; } } diff --git a/DbcParserLib/Model/CustomPropertyDefinition.cs b/DbcParserLib/Model/CustomPropertyDefinition.cs index a48b9c1..93b132c 100644 --- a/DbcParserLib/Model/CustomPropertyDefinition.cs +++ b/DbcParserLib/Model/CustomPropertyDefinition.cs @@ -29,8 +29,7 @@ public void SetCustomPropertyDefaultValue(string value) StringCustomProperty.Default = value; break; case DbcDataType.Enum: - if (EnumCustomProperty.Definition.Contains(value)) - EnumCustomProperty.Default = value; + EnumCustomProperty.Default = value; break; } } diff --git a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs index b3d2a59..5a601c7 100644 --- a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs @@ -71,7 +71,10 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin }; } else if (match.Groups[9].Value == "STRING") + { dataType = DbcDataType.String; + customProperty.StringCustomProperty = new StringCustomPropertyDefinition(); + } else if (match.Groups[10].Value.StartsWith("ENUM ")) { dataType = DbcDataType.Enum; From 1117c67989c007c7ec689dd451eed726b71aba27 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Wed, 22 Feb 2023 19:02:14 +0100 Subject: [PATCH 6/9] Code refactoring --- DbcParserLib/Model/CustomProperty.cs | 37 +++++++------------ .../Model/CustomPropertyDefinition.cs | 18 +++------ .../Parsers/PropertiesDefinitionLineParser.cs | 4 +- 3 files changed, 22 insertions(+), 37 deletions(-) diff --git a/DbcParserLib/Model/CustomProperty.cs b/DbcParserLib/Model/CustomProperty.cs index 3f47107..a2f0f63 100644 --- a/DbcParserLib/Model/CustomProperty.cs +++ b/DbcParserLib/Model/CustomProperty.cs @@ -8,41 +8,41 @@ namespace DbcParserLib.Model { public class CustomProperty { - private CustomPropertyDefinition m_customPropertyDefinition; + private readonly CustomPropertyDefinition m_customPropertyDefinition; public CustomProperty(CustomPropertyDefinition customPropertyDefinition) { m_customPropertyDefinition = customPropertyDefinition; } - public IntegerCustomProperty IntegerCustomProperty { get; set; } - public FloatCustomProperty FloatCustomProperty { get; set; } - public StringCustomProperty StringCustomProperty { get; set; } + public CustomPropertyValue IntegerCustomProperty { get; set; } + public CustomPropertyValue FloatCustomProperty { get; set; } + public CustomPropertyValue StringCustomProperty { get; set; } public void SetCustomPropertyValue(string value) { switch (m_customPropertyDefinition.DataType) { case DbcDataType.Integer: - IntegerCustomProperty = new IntegerCustomProperty() + IntegerCustomProperty = new CustomPropertyValue() { Value = int.Parse(value, CultureInfo.InvariantCulture) }; break; case DbcDataType.Float: - FloatCustomProperty = new FloatCustomProperty() + FloatCustomProperty = new CustomPropertyValue() { Value = float.Parse(value, CultureInfo.InvariantCulture) }; break; case DbcDataType.String: - StringCustomProperty = new StringCustomProperty() + StringCustomProperty = new CustomPropertyValue() { Value = value }; break; case DbcDataType.Enum: - StringCustomProperty = new StringCustomProperty() + StringCustomProperty = new CustomPropertyValue() { Value = value }; @@ -55,25 +55,25 @@ public void SetCustomPropertyValueFromDefault() switch (m_customPropertyDefinition.DataType) { case DbcDataType.Integer: - IntegerCustomProperty = new IntegerCustomProperty() + IntegerCustomProperty = new CustomPropertyValue() { Value = m_customPropertyDefinition.IntegerCustomProperty.Default }; break; case DbcDataType.Float: - FloatCustomProperty = new FloatCustomProperty() + FloatCustomProperty = new CustomPropertyValue() { Value = m_customPropertyDefinition.FloatCustomProperty.Default }; break; case DbcDataType.String: - StringCustomProperty = new StringCustomProperty() + StringCustomProperty = new CustomPropertyValue() { Value = m_customPropertyDefinition.StringCustomProperty.Default }; break; case DbcDataType.Enum: - StringCustomProperty = new StringCustomProperty() + StringCustomProperty = new CustomPropertyValue() { Value = m_customPropertyDefinition.EnumCustomProperty.Default }; @@ -82,17 +82,8 @@ public void SetCustomPropertyValueFromDefault() } } - public class IntegerCustomProperty + public class CustomPropertyValue { - public int Value { get; set; } - } - - public class FloatCustomProperty - { - public double Value { get; set; } - } - public class StringCustomProperty - { - public string Value { get; set; } + public T Value { get; set; } } } diff --git a/DbcParserLib/Model/CustomPropertyDefinition.cs b/DbcParserLib/Model/CustomPropertyDefinition.cs index 93b132c..f602246 100644 --- a/DbcParserLib/Model/CustomPropertyDefinition.cs +++ b/DbcParserLib/Model/CustomPropertyDefinition.cs @@ -10,8 +10,8 @@ public class CustomPropertyDefinition { public string Name { get; set; } public DbcDataType DataType { get; set; } - public IntegerCustomPropertyDefinition IntegerCustomProperty { get; set; } - public FloatCustomPropertyDefinition FloatCustomProperty { get; set; } + public NumericCustomPropertyDefinition IntegerCustomProperty { get; set; } + public NumericCustomPropertyDefinition FloatCustomProperty { get; set; } public StringCustomPropertyDefinition StringCustomProperty { get; set; } public EnumCustomPropertyDefinition EnumCustomProperty { get; set; } @@ -35,19 +35,13 @@ public void SetCustomPropertyDefaultValue(string value) } } - public class IntegerCustomPropertyDefinition + public class NumericCustomPropertyDefinition { - public int Maximum { get; set; } - public int Minimum { get; set; } - public int Default { get; set; } + public T Maximum { get; set; } + public T Minimum { get; set; } + public T Default { get; set; } } - public class FloatCustomPropertyDefinition - { - public double Maximum { get; set; } - public double Minimum { get; set; } - public double Default { get; set; } - } public class StringCustomPropertyDefinition { public string Default { get; set; } diff --git a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs index 5a601c7..1223391 100644 --- a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs @@ -55,7 +55,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin DbcDataType dataType = DbcDataType.Integer; if (match.Groups[3].Value == "INT" || match.Groups[3].Value == "HEX") { - customProperty.IntegerCustomProperty = new IntegerCustomPropertyDefinition + customProperty.IntegerCustomProperty = new NumericCustomPropertyDefinition { Minimum = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture), Maximum = int.Parse(match.Groups[5].Value, CultureInfo.InvariantCulture), @@ -64,7 +64,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin else if (match.Groups[6].Value == "FLOAT") { dataType = DbcDataType.Float; - customProperty.FloatCustomProperty = new FloatCustomPropertyDefinition + customProperty.FloatCustomProperty = new NumericCustomPropertyDefinition { Minimum = double.Parse(match.Groups[7].Value, CultureInfo.InvariantCulture), Maximum = double.Parse(match.Groups[8].Value, CultureInfo.InvariantCulture), From 515468294ee159090738a5d7db1b42c00fe8a8ad Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Fri, 24 Feb 2023 15:29:53 +0100 Subject: [PATCH 7/9] Immutable classes for Message, Node, Signal. Regex improvement. Added some tests. Code refactoring - Node, Message and Signal classes are now immutable - Created new mutable classes for Node, Message and Signal - CustomProperties (BA_) regex now supports scientific notation for double - Added tests for regex scientific notation support - Added Enum and Hex properties in CustomProperty and CustomPropertyDefinition classes - Updated tests to support new classes - Code refactoring --- DbcParserLib.Tests/DbcBuilderTests.cs | 151 +++++++++--------- DbcParserLib.Tests/ExtensionMethodsTests.cs | 56 +++---- DbcParserLib.Tests/MessageLineParserTests.cs | 8 +- DbcParserLib.Tests/NodeLineParserTests.cs | 4 +- DbcParserLib.Tests/PackerTests.cs | 68 ++++---- DbcParserLib.Tests/ParserTests.cs | 2 +- .../PropertiesLineParserTests.cs | 63 +++++++- DbcParserLib.Tests/SignalLineParserTests.cs | 16 +- DbcParserLib/DbcBuilder.cs | 38 +++-- DbcParserLib/IDbcBuilder.cs | 6 +- DbcParserLib/Model/CustomProperty.cs | 20 ++- .../Model/CustomPropertyDefinition.cs | 8 +- DbcParserLib/Model/Message.cs | 56 +++++++ DbcParserLib/Model/Node.cs | 71 ++------ DbcParserLib/Model/Signal.cs | 112 +++++++++++++ DbcParserLib/Parsers/MessageLineParser.cs | 2 +- DbcParserLib/Parsers/NodeLineParser.cs | 2 +- .../Parsers/PropertiesDefinitionLineParser.cs | 7 +- DbcParserLib/Parsers/PropertiesLineParser.cs | 2 +- DbcParserLib/Parsers/SignalLineParser.cs | 4 +- 20 files changed, 450 insertions(+), 246 deletions(-) create mode 100644 DbcParserLib/Model/Message.cs create mode 100644 DbcParserLib/Model/Signal.cs diff --git a/DbcParserLib.Tests/DbcBuilderTests.cs b/DbcParserLib.Tests/DbcBuilderTests.cs index e21358c..97651e9 100644 --- a/DbcParserLib.Tests/DbcBuilderTests.cs +++ b/DbcParserLib.Tests/DbcBuilderTests.cs @@ -37,22 +37,22 @@ public void NoInteractionProduceAnEmptyDbc() public void SingleNodeIsAdded() { var builder = new DbcBuilder(); - var node = new Node { Name = "nodeName" }; + var node = new EditableNode { Name = "nodeName" }; builder.AddNode(node); var dbc = builder.Build(); Assert.AreEqual(1, dbc.Nodes.Count()); - Assert.AreEqual(node, dbc.Nodes.First()); + Assert.AreEqual("nodeName", dbc.Nodes.First().Name); } [Test] public void DuplicatedNodesAreSkipped() { var builder = new DbcBuilder(); - var node = new Node { Name = "nodeName" }; - var node2 = new Node { Name = "nodeName2" }; - var node3 = new Node { Name = "nodeName" }; + var node = new EditableNode { Name = "nodeName" }; + var node2 = new EditableNode { Name = "nodeName2" }; + var node3 = new EditableNode { Name = "nodeName" }; builder.AddNode(node); builder.AddNode(node2); builder.AddNode(node3); @@ -60,22 +60,22 @@ public void DuplicatedNodesAreSkipped() var dbc = builder.Build(); Assert.AreEqual(2, dbc.Nodes.Count()); - Assert.AreEqual(node, dbc.Nodes.First()); - Assert.AreEqual(node2, dbc.Nodes.Skip(1).First()); + Assert.AreEqual("nodeName", dbc.Nodes.First().Name); + Assert.AreEqual("nodeName2", dbc.Nodes.Skip(1).First().Name); } [Test] public void NodeCommentIsAddedToNode() { var builder = new DbcBuilder(); - var node = new Node { Name = "nodeName" }; + var node = new EditableNode { Name = "nodeName" }; builder.AddNode(node); builder.AddNodeComment("nodeName", "this is a comment"); var dbc = builder.Build(); Assert.AreEqual(1, dbc.Nodes.Count()); - Assert.AreEqual(node, dbc.Nodes.First()); + Assert.AreEqual("nodeName", dbc.Nodes.First().Name); Assert.AreEqual("this is a comment", dbc.Nodes.First().Comment); } @@ -83,14 +83,14 @@ public void NodeCommentIsAddedToNode() public void NodeCommentIsSkippedIfNodeIsNotFound() { var builder = new DbcBuilder(); - var node = new Node { Name = "nodeName" }; + var node = new EditableNode { Name = "nodeName" }; builder.AddNode(node); builder.AddNodeComment("anotherNodeName", "this is a comment"); var dbc = builder.Build(); Assert.AreEqual(1, dbc.Nodes.Count()); - Assert.AreEqual(node, dbc.Nodes.First()); + Assert.AreEqual("nodeName", dbc.Nodes.First().Name); Assert.IsNull(dbc.Nodes.First().Comment); } @@ -98,27 +98,26 @@ public void NodeCommentIsSkippedIfNodeIsNotFound() public void MessageIsAdded() { var builder = new DbcBuilder(); - var message = new Message { }; + var message = new EditableMessage { }; builder.AddMessage(message); var dbc = builder.Build(); Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); } [Test] public void CommentIsAddedToMessage() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); builder.AddMessageComment(234, "comment"); var dbc = builder.Build(); Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); Assert.AreEqual("comment", dbc.Messages.First().Comment); } @@ -126,14 +125,14 @@ public void CommentIsAddedToMessage() public void CommentIsNotAddedToMissingMessage() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); builder.AddMessageComment(235, "comment"); var dbc = builder.Build(); Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); Assert.IsNull(dbc.Messages.First().Comment); } @@ -141,19 +140,19 @@ public void CommentIsNotAddedToMissingMessage() public void SignalIsAddedToCurrentMessage() { var builder = new DbcBuilder(); - var message1 = new Message { ID = 234 }; + var message1 = new EditableMessage { ID = 234 }; builder.AddMessage(message1); - var signal1 = new Signal { Name = "name1" }; + var signal1 = new EditableSignal { Name = "name1" }; builder.AddSignal(signal1); - var message2 = new Message { ID = 235 }; + var message2 = new EditableMessage { ID = 235 }; builder.AddMessage(message2); - var signal2 = new Signal { Name = "name2" }; + var signal2 = new EditableSignal { Name = "name2" }; builder.AddSignal(signal2); - var signal3 = new Signal { Name = "name3" }; + var signal3 = new EditableSignal { Name = "name3" }; builder.AddSignal(signal3); var dbc = builder.Build(); @@ -162,21 +161,21 @@ public void SignalIsAddedToCurrentMessage() Assert.AreEqual(2, dbc.Messages.Count()); var messagesToArray = dbc.Messages.ToArray(); - Assert.AreEqual(message1, messagesToArray[0]); + Assert.AreEqual(234, messagesToArray[0].ID); Assert.AreEqual(1, messagesToArray[0].Signals.Count()); - Assert.AreEqual(signal1, messagesToArray[0].Signals.First()); + Assert.AreEqual("name1", messagesToArray[0].Signals.First().Name); - Assert.AreEqual(message2, messagesToArray[1]); + Assert.AreEqual(235, messagesToArray[1].ID); Assert.AreEqual(2, messagesToArray[1].Signals.Count()); - Assert.AreEqual(signal2, messagesToArray[1].Signals.First()); - Assert.AreEqual(signal3, messagesToArray[1].Signals.Skip(1).First()); + Assert.AreEqual("name2", messagesToArray[1].Signals.First().Name); + Assert.AreEqual("name3", messagesToArray[1].Signals.Skip(1).First().Name); } [Test] public void SignalIsNotAddedIfNoMessageHasBeenProvidedFirst() { var builder = new DbcBuilder(); - builder.AddSignal(new Signal { }); + builder.AddSignal(new EditableSignal { }); var dbc = builder.Build(); Assert.IsEmpty(dbc.Nodes); @@ -187,9 +186,9 @@ public void SignalIsNotAddedIfNoMessageHasBeenProvidedFirst() public void CommentIsAddedToSignal() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(234, "name1", "comment"); @@ -197,8 +196,8 @@ public void CommentIsAddedToSignal() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.AreEqual("comment", dbc.Messages.First().Signals.First().Comment); } @@ -206,9 +205,9 @@ public void CommentIsAddedToSignal() public void CommentIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(235, "name1", "comment"); @@ -216,8 +215,8 @@ public void CommentIsNotAddedToMissingSignalMessageId() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().Comment); } @@ -225,9 +224,9 @@ public void CommentIsNotAddedToMissingSignalMessageId() public void CommentIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(234, "name2", "comment"); @@ -235,8 +234,8 @@ public void CommentIsNotAddedToMissingSignalName() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().Comment); } @@ -244,9 +243,9 @@ public void CommentIsNotAddedToMissingSignalName() public void TableValuesAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -255,8 +254,8 @@ public void TableValuesAreAddedToSignal() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.AreEqual(testValuesDict, dbc.Messages.First().Signals.First().ValueTableMap); Assert.AreEqual("1 fake", dbc.Messages.First().Signals.First().ValueTable); } @@ -265,10 +264,10 @@ public void TableValuesAreAddedToSignal() public void TableValuesWithExtendedMessageIdAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new Message { ID = 2566896411 }; + var message = new EditableMessage { ID = 2566896411 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -277,8 +276,8 @@ public void TableValuesWithExtendedMessageIdAreAddedToSignal() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(message.ID, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.AreEqual(testValuesDict, dbc.Messages.First().Signals.First().ValueTableMap); Assert.AreEqual("1 fake", dbc.Messages.First().Signals.First().ValueTable); } @@ -287,9 +286,9 @@ public void TableValuesWithExtendedMessageIdAreAddedToSignal() public void TableValueIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -298,8 +297,8 @@ public void TableValueIsNotAddedToMissingSignalMessageId() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTableMap); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTable); } @@ -308,9 +307,9 @@ public void TableValueIsNotAddedToMissingSignalMessageId() public void TableValueIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -319,8 +318,8 @@ public void TableValueIsNotAddedToMissingSignalName() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTableMap); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTable); } @@ -329,9 +328,9 @@ public void TableValueIsNotAddedToMissingSignalName() public void NamedTableValuesAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -342,8 +341,8 @@ public void NamedTableValuesAreAddedToSignal() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.AreEqual(testValuesDict, dbc.Messages.First().Signals.First().ValueTableMap); Assert.AreEqual("1 fake", dbc.Messages.First().Signals.First().ValueTable); } @@ -352,9 +351,9 @@ public void NamedTableValuesAreAddedToSignal() public void NamedTableValueIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -365,8 +364,8 @@ public void NamedTableValueIsNotAddedToMissingSignalMessageId() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTableMap); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTable); } @@ -375,9 +374,9 @@ public void NamedTableValueIsNotAddedToMissingSignalMessageId() public void NamedTableValueIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -388,8 +387,8 @@ public void NamedTableValueIsNotAddedToMissingSignalName() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTableMap); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTable); } @@ -398,9 +397,9 @@ public void NamedTableValueIsNotAddedToMissingSignalName() public void NamedTableValueIsNotAddedIfTableNameDoesNotExist() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); builder.LinkNamedTableToSignal(234, "name1", "aTableName"); @@ -408,8 +407,8 @@ public void NamedTableValueIsNotAddedIfTableNameDoesNotExist() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.IsNull(dbc.Messages.First().Signals.First().ValueTable); } @@ -447,9 +446,9 @@ public void NamedTablesWithSameNameAreManaged() public void NamedTablesWithSameNameOverridesPrevious() { var builder = new DbcBuilder(); - var message = new Message { ID = 234 }; + var message = new EditableMessage { ID = 234 }; builder.AddMessage(message); - var signal = new Signal { Name = "name1" }; + var signal = new EditableSignal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake1" } }; var testValuesDict2 = new Dictionary() { { 2, "fake2" } }; @@ -462,8 +461,8 @@ public void NamedTablesWithSameNameOverridesPrevious() Assert.IsEmpty(dbc.Nodes); Assert.AreEqual(1, dbc.Messages.Count()); - Assert.AreEqual(message, dbc.Messages.First()); - Assert.AreEqual(signal, dbc.Messages.First().Signals.First()); + Assert.AreEqual(234, dbc.Messages.First().ID); + Assert.AreEqual("name1", dbc.Messages.First().Signals.First().Name); Assert.AreEqual(testValuesDict2, dbc.Messages.First().Signals.First().ValueTableMap); Assert.AreEqual("2 fake2", dbc.Messages.First().Signals.First().ValueTable); } diff --git a/DbcParserLib.Tests/ExtensionMethodsTests.cs b/DbcParserLib.Tests/ExtensionMethodsTests.cs index 7139888..d689117 100644 --- a/DbcParserLib.Tests/ExtensionMethodsTests.cs +++ b/DbcParserLib.Tests/ExtensionMethodsTests.cs @@ -10,40 +10,40 @@ public class ExtensionMethodsTests [Test] public void MotorolaTest() { - var sig = new Signal + var sig = new EditableSignal { ByteOrder = 0, // 0 = Big Endian (Motorola), 1 = Little Endian (Intel) }; - Assert.IsTrue(sig.Motorola()); - Assert.IsTrue(sig.Msb()); - Assert.IsFalse(sig.Intel()); - Assert.IsFalse(sig.Lsb()); + Assert.IsTrue(sig.CreateSignal().Motorola()); + Assert.IsTrue(sig.CreateSignal().Msb()); + Assert.IsFalse(sig.CreateSignal().Intel()); + Assert.IsFalse(sig.CreateSignal().Lsb()); } [Test] public void IntelTest() { - var sig = new Signal + var sig = new EditableSignal { ByteOrder = 1, // 0 = Big Endian (Motorola), 1 = Little Endian (Intel) }; - Assert.IsFalse(sig.Motorola()); - Assert.IsFalse(sig.Msb()); - Assert.IsTrue(sig.Intel()); - Assert.IsTrue(sig.Lsb()); + Assert.IsFalse(sig.CreateSignal().Motorola()); + Assert.IsFalse(sig.CreateSignal().Msb()); + Assert.IsTrue(sig.CreateSignal().Intel()); + Assert.IsTrue(sig.CreateSignal().Lsb()); } [Test] public void NoMultiplexingTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = null, }; - var multiplexing = sig.MultiplexingInfo(); + var multiplexing = sig.CreateSignal().MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.None, multiplexing.Role); Assert.AreEqual(0, multiplexing.Group); } @@ -51,12 +51,12 @@ public void NoMultiplexingTest() [Test] public void MultiplexorTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = "M", }; - var multiplexing = sig.MultiplexingInfo(); + var multiplexing = sig.CreateSignal().MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexor, multiplexing.Role); Assert.AreEqual(0, multiplexing.Group); } @@ -64,12 +64,12 @@ public void MultiplexorTest() [Test] public void MultiplexedSingleDigitTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = "m3", }; - var multiplexing = sig.MultiplexingInfo(); + var multiplexing = sig.CreateSignal().MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(3, multiplexing.Group); } @@ -77,12 +77,12 @@ public void MultiplexedSingleDigitTest() [Test] public void ExtendedMultiplexingIsPartiallySupportedTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = "m3M", }; - var multiplexing = sig.MultiplexingInfo(); + var multiplexing = sig.CreateSignal().MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(3, multiplexing.Group); } @@ -90,12 +90,12 @@ public void ExtendedMultiplexingIsPartiallySupportedTest() [Test] public void MultiplexedDoubleDigitTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = "m12", }; - var multiplexing = sig.MultiplexingInfo(); + var multiplexing = sig.CreateSignal().MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(12, multiplexing.Group); } @@ -103,36 +103,36 @@ public void MultiplexedDoubleDigitTest() [Test] public void MultiplexedMessageTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = "M", }; - var message = new Message(); + var message = new EditableMessage(); message.Signals.Add(sig); - Assert.IsTrue(message.IsMultiplexed()); + Assert.IsTrue(message.CreateMessage().IsMultiplexed()); } [Test] public void MessageWithNoMutiplexorIsNotMultiplexedTest() { - var sig = new Signal + var sig = new EditableSignal { Multiplexing = null, }; - var message = new Message(); + var message = new EditableMessage(); message.Signals.Add(sig); - Assert.IsFalse(message.IsMultiplexed()); + Assert.IsFalse(message.CreateMessage().IsMultiplexed()); } [Test] public void EmptyMessageIsNotMultiplexedTest() { - var message = new Message(); - Assert.IsFalse(message.IsMultiplexed()); + var message = new EditableMessage(); + Assert.IsFalse(message.CreateMessage().IsMultiplexed()); } } } \ No newline at end of file diff --git a/DbcParserLib.Tests/MessageLineParserTests.cs b/DbcParserLib.Tests/MessageLineParserTests.cs index 5fee29a..737df1b 100644 --- a/DbcParserLib.Tests/MessageLineParserTests.cs +++ b/DbcParserLib.Tests/MessageLineParserTests.cs @@ -71,8 +71,8 @@ public void MalformedLineIsAcceptedWithoutInteraction() public void FullLineIsParsed() { var dbcBuilderMock = m_repository.Create(); - dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) - .Callback(message => + dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) + .Callback(message => { Assert.AreEqual(1041, message.ID); Assert.AreEqual("DOORS_SEATBELTS", message.Name); @@ -91,8 +91,8 @@ public void FullLineIsParsed() public void FullLineWithSomeRamdomSpacesIsParsed() { var dbcBuilderMock = m_repository.Create(); - dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) - .Callback(message => + dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) + .Callback(message => { Assert.AreEqual(1041, message.ID); Assert.AreEqual("DOORS_SEATBELTS", message.Name); diff --git a/DbcParserLib.Tests/NodeLineParserTests.cs b/DbcParserLib.Tests/NodeLineParserTests.cs index 93c4830..b0441a6 100644 --- a/DbcParserLib.Tests/NodeLineParserTests.cs +++ b/DbcParserLib.Tests/NodeLineParserTests.cs @@ -78,8 +78,8 @@ public void FullLineIsParsed() }; var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddNode(It.IsAny())) - .Callback(node => + dbcBuilderMock.Setup(mock => mock.AddNode(It.IsAny())) + .Callback(node => { Assert.IsFalse(string.IsNullOrWhiteSpace(node.Name)); Assert.IsTrue(string.IsNullOrWhiteSpace(node.Comment)); diff --git a/DbcParserLib.Tests/PackerTests.cs b/DbcParserLib.Tests/PackerTests.cs index 6f4d9d4..70aa5d4 100644 --- a/DbcParserLib.Tests/PackerTests.cs +++ b/DbcParserLib.Tests/PackerTests.cs @@ -9,7 +9,7 @@ public class PackerTests [Test] public void SimplePackingTestSigned() { - var sig = new Signal + var sig = new EditableSignal { Length = 14, StartBit = 2, @@ -19,10 +19,10 @@ public void SimplePackingTestSigned() Offset = 20 }; - var txMsg = Packer.TxSignalPack(-34.3, sig); + var txMsg = Packer.TxSignalPack(-34.3, sig.CreateSignal()); Assert.AreEqual(43816, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(-34.3, val, 1e-2); } @@ -32,7 +32,7 @@ public void SimplePackingTestSigned() [TestCase((ushort)12, 13334048092160ul)] public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) { - var sig = new Signal + var sig = new EditableSignal { Length = 32, StartBit = start, @@ -43,10 +43,10 @@ public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) }; var expected = -34.3f; - var txMsg = Packer.TxSignalPack(expected, sig); + var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); Assert.AreEqual(packet, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(expected, val, 1e-2); } @@ -56,7 +56,7 @@ public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) [TestCase((ushort)12, 105991844730880ul)] public void FloatBigEndianValuePackingTest(ushort start, ulong packet) { - var sig = new Signal + var sig = new EditableSignal { Length = 32, StartBit = start, @@ -67,17 +67,17 @@ public void FloatBigEndianValuePackingTest(ushort start, ulong packet) }; var value = -34.3f; - var txMsg = Packer.TxSignalPack(value, sig); + var txMsg = Packer.TxSignalPack(value, sig.CreateSignal()); Assert.AreEqual(packet, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(value, val, 1e-2); } [Test] public void DoubleLittleEndianValuePackingTest() { - var sig = new Signal + var sig = new EditableSignal { Length = 64, StartBit = 0, @@ -88,17 +88,17 @@ public void DoubleLittleEndianValuePackingTest() }; var expected = -34.3567; - var txMsg = Packer.TxSignalPack(expected, sig); + var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); Assert.AreEqual(13853404129830452697, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(expected, val, 1e-2); } [Test] public void DoubleBigEndianValuePackingTest() { - var sig = new Signal + var sig = new EditableSignal { Length = 64, StartBit = 7, @@ -109,17 +109,17 @@ public void DoubleBigEndianValuePackingTest() }; var expected = -34.35564; - var txMsg = Packer.TxSignalPack(expected, sig); + var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); Assert.AreEqual(2419432028705210816, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(expected, val, 1e-2); } [Test] public void SimplePackingTestNonSigned() { - var sig = new Signal + var sig = new EditableSignal { Length = 16, StartBit = 24, @@ -129,20 +129,20 @@ public void SimplePackingTestNonSigned() Offset = 0 }; - var txMsg = Packer.TxSignalPack(800, sig); + var txMsg = Packer.TxSignalPack(800, sig.CreateSignal()); Assert.AreEqual(107374182400, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(800, val); - val = Packer.RxSignalUnpack(9655716608953581040, sig); + val = Packer.RxSignalUnpack(9655716608953581040, sig.CreateSignal()); Assert.AreEqual(800, val); } [Test] public void PackingTest64Bit() { - var sig = new Signal + var sig = new EditableSignal { Length = 64, StartBit = 0, @@ -152,10 +152,10 @@ public void PackingTest64Bit() Offset = 0 }; - var txMsg = Packer.TxSignalPack(396.31676720860366, sig); + var txMsg = Packer.TxSignalPack(396.31676720860366, sig.CreateSignal()); Assert.AreEqual(3963167672086036480, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(396.31676720860366, val); } @@ -163,7 +163,7 @@ public void PackingTest64Bit() [Test] public void UnPackingTestMultipleUnpacks() { - var sig = new Signal + var sig = new EditableSignal { Length = 8, StartBit = 56, @@ -173,13 +173,13 @@ public void UnPackingTestMultipleUnpacks() Offset = -125 }; - var txMsg = Packer.TxSignalPack(8, sig); + var txMsg = Packer.TxSignalPack(8, sig.CreateSignal()); Assert.AreEqual(9583660007044415488, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(8, val); - val = Packer.RxSignalUnpack(9655716608953581040, sig); + val = Packer.RxSignalUnpack(9655716608953581040, sig.CreateSignal()); Assert.AreEqual(8, val); } @@ -187,7 +187,7 @@ public void UnPackingTestMultipleUnpacks() [Test] public void BitPackingTest1() { - var sig = new Signal + var sig = new EditableSignal { Length = 1, StartBit = 18, @@ -197,13 +197,13 @@ public void BitPackingTest1() Offset = 0 }; - var txMsg = Packer.TxSignalPack(1, sig); + var txMsg = Packer.TxSignalPack(1, sig.CreateSignal()); Assert.AreEqual(262144, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(1, val); - val = Packer.RxSignalUnpack(140737488617472, sig); + val = Packer.RxSignalUnpack(140737488617472, sig.CreateSignal()); Assert.AreEqual(1, val); } @@ -211,7 +211,7 @@ public void BitPackingTest1() [Test] public void BitPackingTest2() { - var sig = new Signal + var sig = new EditableSignal { Length = 3, StartBit = 6, @@ -221,13 +221,13 @@ public void BitPackingTest2() Offset = 0 }; - var txMsg = Packer.TxSignalPack(6, sig); + var txMsg = Packer.TxSignalPack(6, sig.CreateSignal()); Assert.AreEqual(384, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig); + var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); Assert.AreEqual(6, val); - val = Packer.RxSignalUnpack(498806260540323729, sig); + val = Packer.RxSignalUnpack(498806260540323729, sig.CreateSignal()); Assert.AreEqual(6, val); } } diff --git a/DbcParserLib.Tests/ParserTests.cs b/DbcParserLib.Tests/ParserTests.cs index cdfe2d8..229d719 100644 --- a/DbcParserLib.Tests/ParserTests.cs +++ b/DbcParserLib.Tests/ParserTests.cs @@ -327,7 +327,7 @@ public void UserDefinedAttributesTest() var signal = dbc.Messages.Single().Signals.FirstOrDefault(x => x.Name.Equals("COUNTER_ALT")); Assert.IsNotNull(signal); Assert.AreEqual(2, signal.CustomProperties.Count()); - Assert.AreEqual("ThirdVal", signal.CustomProperties["EnumAttributeName"].StringCustomProperty.Value); + Assert.AreEqual("ThirdVal", signal.CustomProperties["EnumAttributeName"].EnumCustomProperty.Value); Assert.AreEqual("DefaultString", signal.CustomProperties["StringAttribute"].StringCustomProperty.Value); } } diff --git a/DbcParserLib.Tests/PropertiesLineParserTests.cs b/DbcParserLib.Tests/PropertiesLineParserTests.cs index 63fa2d9..c9e6af5 100644 --- a/DbcParserLib.Tests/PropertiesLineParserTests.cs +++ b/DbcParserLib.Tests/PropertiesLineParserTests.cs @@ -10,6 +10,20 @@ namespace DbcParserLib.Tests { public class PropertiesLineParserTests { + private MockRepository m_repository; + + [SetUp] + public void Setup() + { + m_repository = new MockRepository(MockBehavior.Strict); + } + + [TearDown] + public void Teardown() + { + m_repository.VerifyAll(); + } + private static List CreateParser() { return new List() { @@ -50,6 +64,25 @@ public void FloatDefinitionCustomPropertyIsParsedTest() Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 7.5;", sigInitialValueLineParser, builder, nextLineProvider)); } + [Test] + public void ScientificNotationDefinitionCustomPropertyIsParsedTest() + { + var dbcBuilderMock = m_repository.Create(); + var nextLineProviderMock = m_repository.Create(); + + dbcBuilderMock.Setup(mock => mock.AddCustomProperty(It.IsAny(), It.IsAny())) + .Callback((objectType, customProperty) => + { + Assert.AreEqual("AttributeName", customProperty.Name); + Assert.AreEqual(DbcDataType.Float, customProperty.DataType); + Assert.AreEqual(0, customProperty.FloatCustomProperty.Minimum); + Assert.AreEqual(0.1, customProperty.FloatCustomProperty.Maximum); + }); + + var sigInitialValueLineParser = CreateParser(); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" FLOAT 0 1e-1;", sigInitialValueLineParser, dbcBuilderMock.Object, nextLineProviderMock.Object)); + } + [Test] public void StringDefinitionCustomPropertyIsParsedTest() { @@ -76,7 +109,7 @@ public void EnumDefinitionCustomPropertyIsParsedTest() public void MsgCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new Message { ID = 2394947585 }; + var message = new EditableMessage { ID = 2394947585 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); @@ -94,10 +127,10 @@ public void MsgCustomPropertyIsParsedTest() public void SigCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new Message { ID = 2394947585 }; + var message = new EditableMessage { ID = 2394947585 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); - var signal = new Signal { Name = "sig_name" }; + var signal = new EditableSignal { Name = "sig_name" }; builder.AddSignal(signal); var sigInitialValueLineParser = CreateParser(); @@ -114,7 +147,7 @@ public void SigCustomPropertyIsParsedTest() public void NodeCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var node = new Node { Name = "Node1" }; + var node = new EditableNode { Name = "Node1" }; builder.AddNode(node); var sigInitialValueLineParser = CreateParser(); @@ -124,11 +157,27 @@ public void NodeCustomPropertyIsParsedTest() Assert.IsTrue(ParseLine(@"BA_ ""AttributeName"" BU_ Node1 40;", sigInitialValueLineParser, builder, nextLineProvider)); } + [Test] + public void NodeScientificNotationCustomPropertyIsParsedTest() + { + var builder = new DbcBuilder(); + var node = new EditableNode { Name = "Node1" }; + builder.AddNode(node); + + var dbc = builder.Build(); + var sigInitialValueLineParser = CreateParser(); + var nextLineProvider = new NextLineProvider(new StringReader(string.Empty)); + Assert.IsTrue(ParseLine(@"BA_DEF_ BU_ ""AttributeName"" FLOAT 0 10;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_DEF_DEF_ ""AttributeName"" 5;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.IsTrue(ParseLine(@"BA_ ""AttributeName"" BU_ Node1 0.7e1;", sigInitialValueLineParser, builder, nextLineProvider)); + Assert.AreEqual(dbc.Nodes.First().CustomProperties.First().Value.FloatCustomProperty.Value, 7); + } + [Test] public void NodeMultipleCustomPropertyAreParsedTest() { var builder = new DbcBuilder(); - var node = new Node { Name = "Node1" }; + var node = new EditableNode { Name = "Node1" }; builder.AddNode(node); var sigInitialValueLineParser = CreateParser(); @@ -150,8 +199,8 @@ public void NodeMultipleCustomPropertyAreParsedTest() public void CustomPropertyIsAssignedToDifferentNodesTest() { var builder = new DbcBuilder(); - var node1 = new Node { Name = "Node1" }; - var node2 = new Node { Name = "Node2" }; + var node1 = new EditableNode { Name = "Node1" }; + var node2 = new EditableNode { Name = "Node2" }; builder.AddNode(node1); builder.AddNode(node2); diff --git a/DbcParserLib.Tests/SignalLineParserTests.cs b/DbcParserLib.Tests/SignalLineParserTests.cs index 4ecc4b2..725b407 100644 --- a/DbcParserLib.Tests/SignalLineParserTests.cs +++ b/DbcParserLib.Tests/SignalLineParserTests.cs @@ -75,8 +75,8 @@ public void FullLineIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -104,8 +104,8 @@ public void FullLineMultiplexedIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -133,8 +133,8 @@ public void FullLineMultipleReceiversIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -163,8 +163,8 @@ public void FullLineMultipleReceiversWithSpacesIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index 6991c0e..5c65724 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -15,31 +15,31 @@ internal class ValuesTable public class DbcBuilder : IDbcBuilder { - private readonly ISet m_nodes = new HashSet(new NodeEqualityComparer()); + private readonly ISet m_nodes = new HashSet(new NodeEqualityComparer()); private readonly IDictionary m_namedTablesMap = new Dictionary(); - private readonly IDictionary m_messages = new Dictionary(); - private readonly IDictionary> m_signals = new Dictionary>(); + private readonly IDictionary m_messages = new Dictionary(); + private readonly IDictionary> m_signals = new Dictionary>(); private readonly IDictionary> m_customProperties = new Dictionary>() { {DbcObjectType.Node, new Dictionary()}, {DbcObjectType.Message, new Dictionary()}, {DbcObjectType.Signal, new Dictionary()}, }; - private Message m_currentMessage; + private EditableMessage m_currentMessage; - public void AddNode(Node node) + public void AddNode(EditableNode node) { m_nodes.Add(node); } - public void AddMessage(Message message) + public void AddMessage(EditableMessage message) { m_messages[message.ID] = message; m_currentMessage = message; - m_signals[message.ID] = new Dictionary(); + m_signals[message.ID] = new Dictionary(); } - public void AddSignal(Signal signal) + public void AddSignal(EditableSignal signal) { if (m_currentMessage != null) { @@ -195,7 +195,7 @@ public void LinkNamedTableToSignal(uint messageId, string signalName, string tab } } - private bool TryGetValueMessageSignal(uint messageId, string signalName, out Signal signal) + private bool TryGetValueMessageSignal(uint messageId, string signalName, out EditableSignal signal) { if (m_signals.TryGetValue(messageId, out var signals) && signals.TryGetValue(signalName, out signal)) { @@ -266,13 +266,25 @@ public Dbc Build() message.Value.Signals.AddRange(m_signals[message.Key].Values); } - return new Dbc(m_nodes.ToArray(), m_messages.Values.ToArray()); + var nodes = new List(); + foreach (var node in m_nodes) + { + nodes.Add(node.CreateNode()); + } + + var messages = new List(); + foreach (var message in m_messages.Values) + { + messages.Add(message.CreateMessage()); + } + + return new Dbc(nodes, messages); } } - internal class NodeEqualityComparer : IEqualityComparer +internal class NodeEqualityComparer : IEqualityComparer { - public bool Equals(Node b1, Node b2) + public bool Equals(EditableNode b1, EditableNode b2) { if (b2 == null && b1 == null) return true; @@ -284,7 +296,7 @@ public bool Equals(Node b1, Node b2) return false; } - public int GetHashCode(Node bx) + public int GetHashCode(EditableNode bx) { return bx.Name.GetHashCode(); } diff --git a/DbcParserLib/IDbcBuilder.cs b/DbcParserLib/IDbcBuilder.cs index 266df3b..d935b2a 100644 --- a/DbcParserLib/IDbcBuilder.cs +++ b/DbcParserLib/IDbcBuilder.cs @@ -5,13 +5,13 @@ namespace DbcParserLib { public interface IDbcBuilder { - void AddMessage(Message message); + void AddMessage(EditableMessage message); void AddMessageComment(uint messageId, string comment); void AddMessageCycleTime(uint messageId, int cycleTime); void AddNamedValueTable(string name, IReadOnlyDictionary dictValues, string stringValues); - void AddNode(Node node); + void AddNode(EditableNode node); void AddNodeComment(string nodeName, string comment); - void AddSignal(Signal signal); + void AddSignal(EditableSignal signal); void AddSignalComment(uint messageId, string signalName, string comment); void AddSignalInitialValue(uint messageId, string signalName, double initialValue); void AddSignalValueType(uint messageId, string signalName, DbcValueType valueType); diff --git a/DbcParserLib/Model/CustomProperty.cs b/DbcParserLib/Model/CustomProperty.cs index a2f0f63..9aefd89 100644 --- a/DbcParserLib/Model/CustomProperty.cs +++ b/DbcParserLib/Model/CustomProperty.cs @@ -8,7 +8,7 @@ namespace DbcParserLib.Model { public class CustomProperty { - private readonly CustomPropertyDefinition m_customPropertyDefinition; + public readonly CustomPropertyDefinition m_customPropertyDefinition; public CustomProperty(CustomPropertyDefinition customPropertyDefinition) { @@ -16,8 +16,10 @@ public CustomProperty(CustomPropertyDefinition customPropertyDefinition) } public CustomPropertyValue IntegerCustomProperty { get; set; } + public CustomPropertyValue HexCustomProperty { get; set; } public CustomPropertyValue FloatCustomProperty { get; set; } public CustomPropertyValue StringCustomProperty { get; set; } + public CustomPropertyValue EnumCustomProperty { get; set; } public void SetCustomPropertyValue(string value) { @@ -29,6 +31,12 @@ public void SetCustomPropertyValue(string value) Value = int.Parse(value, CultureInfo.InvariantCulture) }; break; + case DbcDataType.Hex: + HexCustomProperty = new CustomPropertyValue() + { + Value = int.Parse(value, CultureInfo.InvariantCulture) + }; + break; case DbcDataType.Float: FloatCustomProperty = new CustomPropertyValue() { @@ -42,7 +50,7 @@ public void SetCustomPropertyValue(string value) }; break; case DbcDataType.Enum: - StringCustomProperty = new CustomPropertyValue() + EnumCustomProperty = new CustomPropertyValue() { Value = value }; @@ -60,6 +68,12 @@ public void SetCustomPropertyValueFromDefault() Value = m_customPropertyDefinition.IntegerCustomProperty.Default }; break; + case DbcDataType.Hex: + HexCustomProperty = new CustomPropertyValue() + { + Value = m_customPropertyDefinition.HexCustomProperty.Default + }; + break; case DbcDataType.Float: FloatCustomProperty = new CustomPropertyValue() { @@ -73,7 +87,7 @@ public void SetCustomPropertyValueFromDefault() }; break; case DbcDataType.Enum: - StringCustomProperty = new CustomPropertyValue() + EnumCustomProperty = new CustomPropertyValue() { Value = m_customPropertyDefinition.EnumCustomProperty.Default }; diff --git a/DbcParserLib/Model/CustomPropertyDefinition.cs b/DbcParserLib/Model/CustomPropertyDefinition.cs index f602246..2cbbc30 100644 --- a/DbcParserLib/Model/CustomPropertyDefinition.cs +++ b/DbcParserLib/Model/CustomPropertyDefinition.cs @@ -11,6 +11,7 @@ public class CustomPropertyDefinition public string Name { get; set; } public DbcDataType DataType { get; set; } public NumericCustomPropertyDefinition IntegerCustomProperty { get; set; } + public NumericCustomPropertyDefinition HexCustomProperty { get; set; } public NumericCustomPropertyDefinition FloatCustomProperty { get; set; } public StringCustomPropertyDefinition StringCustomProperty { get; set; } public EnumCustomPropertyDefinition EnumCustomProperty { get; set; } @@ -22,6 +23,9 @@ public void SetCustomPropertyDefaultValue(string value) case DbcDataType.Integer: IntegerCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); break; + case DbcDataType.Hex: + HexCustomProperty.Default = int.Parse(value, CultureInfo.InvariantCulture); + break; case DbcDataType.Float: FloatCustomProperty.Default = float.Parse(value, CultureInfo.InvariantCulture); break; @@ -50,7 +54,7 @@ public class StringCustomPropertyDefinition public class EnumCustomPropertyDefinition { public string Default { get; set; } - public string[] Definition { get; set; } + public string[] Values { get; set; } } public enum DbcObjectType @@ -60,6 +64,6 @@ public enum DbcObjectType public enum DbcDataType { - Integer, Float, String, Enum + Integer, Hex, Float, String, Enum } } diff --git a/DbcParserLib/Model/Message.cs b/DbcParserLib/Model/Message.cs new file mode 100644 index 0000000..0c5d8a0 --- /dev/null +++ b/DbcParserLib/Model/Message.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Text; + +namespace DbcParserLib.Model +{ + public class Message + { + public uint ID { get; } + public bool IsExtID { get; } + public string Name { get; } + public ushort DLC { get; } + public string Transmitter { get; } + public string Comment { get; } + public int CycleTime { get; } + public IReadOnlyList Signals; + public IReadOnlyDictionary CustomProperties; + + internal Message(EditableMessage message, IReadOnlyList signals) + { + ID = message.ID; + IsExtID = message.IsExtID; + Name = message.Name; + DLC = message.DLC; + Transmitter = message.Transmitter; + Comment = message.Comment; + CycleTime= message.CycleTime; + Signals = signals; + CustomProperties = message.CustomProperties; + } + } + + public class EditableMessage + { + public uint ID; + public bool IsExtID; + public string Name; + public ushort DLC; + public string Transmitter; + public string Comment; + public int CycleTime; + public List Signals = new List(); + public Dictionary CustomProperties = new Dictionary(); + + public Message CreateMessage() + { + var signals = new List(); + foreach(var signal in Signals) + { + signals.Add(signal.CreateSignal()); + } + return new Message(this, signals); + } + } +} diff --git a/DbcParserLib/Model/Node.cs b/DbcParserLib/Model/Node.cs index 7b78b24..e2b2241 100644 --- a/DbcParserLib/Model/Node.cs +++ b/DbcParserLib/Model/Node.cs @@ -1,75 +1,32 @@ using System; +using System.Collections; using System.Collections.Generic; namespace DbcParserLib.Model { public class Node { - public string Name; - public string Comment; - public readonly IDictionary CustomProperties = new Dictionary(); - } + public string Name { get; } + public string Comment { get; } + public IReadOnlyDictionary CustomProperties; - public class Message - { - public uint ID; - public bool IsExtID; - public string Name; - public ushort DLC; - public string Transmitter; - public string Comment; - public int CycleTime; - public List Signals = new List(); - public readonly IDictionary CustomProperties = new Dictionary(); + internal Node(EditableNode node) + { + Name = node.Name; + Comment = node.Comment; + CustomProperties = node.CustomProperties; + } } - public class Signal + public class EditableNode { - private DbcValueType m_ValueType = DbcValueType.Signed; - - public uint ID; public string Name; - public ushort StartBit; - public ushort Length; - public byte ByteOrder = 1; - [Obsolete("Please use ValueType instead. IsSigned will be removed in future releases")] - public byte IsSigned { get; private set; } = 1; - public DbcValueType ValueType - { - get - { - return m_ValueType; - } - set - { - m_ValueType = value; - IsSigned = (byte)(value == DbcValueType.Unsigned ? 0 : 1); - } - } - public double InitialValue; - public double Factor = 1; - public bool IsInteger = false; - public double Offset; - public double Minimum; - public double Maximum; - public string Unit; - public string[] Receiver; - [Obsolete("Please use ValueTableMap instead. ValueTable will be removed in future releases")] - public string ValueTable { get; private set; } - public IReadOnlyDictionary ValueTableMap { get; private set; } public string Comment; - public string Multiplexing; - public readonly IDictionary CustomProperties = new Dictionary(); + public Dictionary CustomProperties = new Dictionary(); - internal void SetValueTable(IReadOnlyDictionary dictValues, string stringValues) + public Node CreateNode() { - ValueTableMap = dictValues; - ValueTable = stringValues; + return new Node(this); } } - - public enum DbcValueType - { - Signed, Unsigned, IEEEFloat, IEEEDouble - } } \ No newline at end of file diff --git a/DbcParserLib/Model/Signal.cs b/DbcParserLib/Model/Signal.cs new file mode 100644 index 0000000..372336a --- /dev/null +++ b/DbcParserLib/Model/Signal.cs @@ -0,0 +1,112 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace DbcParserLib.Model +{ + public class Signal + { + public uint ID { get; } + public string Name { get; } + public ushort StartBit { get; } + public ushort Length { get; } + public byte ByteOrder { get; } + [Obsolete("Please use ValueType instead. IsSigned will be removed in future releases")] + public byte IsSigned { get; } + public DbcValueType ValueType { get; } + + public double InitialValue { get; } + public double Factor { get; } + public bool IsInteger { get; } + public double Offset { get; } + public double Minimum { get; } + public double Maximum { get; } + public string Unit { get; } + public string[] Receiver { get; } + [Obsolete("Please use ValueTableMap instead. ValueTable will be removed in future releases")] + public string ValueTable { get; } + public IReadOnlyDictionary ValueTableMap { get; } + public string Comment { get; } + public string Multiplexing { get; } + public readonly IReadOnlyDictionary CustomProperties; + + internal Signal(EditableSignal signal) + { + ID = signal.ID; + Name = signal.Name; + StartBit = signal.StartBit; + Length = signal.Length; + ByteOrder = signal.ByteOrder; + IsSigned = signal.IsSigned; + ValueType = signal.ValueType; + InitialValue = signal.InitialValue; + Factor = signal.Factor; + IsInteger = signal.IsInteger; + Offset = signal.Offset; + Minimum = signal.Minimum; + Maximum = signal.Maximum; + Unit = signal.Unit; + Receiver = signal.Receiver; + ValueTable = signal.ValueTable; + ValueTableMap = signal.ValueTableMap; + Comment = signal.Comment; + Multiplexing = signal.Multiplexing; + CustomProperties = signal.CustomProperties; + } + } + + public class EditableSignal + { + private DbcValueType m_ValueType = DbcValueType.Signed; + + public uint ID; + public string Name; + public ushort StartBit; + public ushort Length; + public byte ByteOrder = 1; + [Obsolete("Please use ValueType instead. IsSigned will be removed in future releases")] + public byte IsSigned { get; private set; } = 1; + public DbcValueType ValueType + { + get + { + return m_ValueType; + } + set + { + m_ValueType = value; + IsSigned = (byte)(value == DbcValueType.Unsigned ? 0 : 1); + } + } + public double InitialValue; + public double Factor = 1; + public bool IsInteger = false; + public double Offset; + public double Minimum; + public double Maximum; + public string Unit; + public string[] Receiver; + [Obsolete("Please use ValueTableMap instead. ValueTable will be removed in future releases")] + public string ValueTable { get; private set; } + public IReadOnlyDictionary ValueTableMap { get; private set; } + public string Comment; + public string Multiplexing; + public readonly Dictionary CustomProperties = new Dictionary(); + + internal void SetValueTable(IReadOnlyDictionary dictValues, string stringValues) + { + ValueTableMap = dictValues; + ValueTable = stringValues; + } + + public Signal CreateSignal() + { + return new Signal(this); + } + } + + public enum DbcValueType + { + Signed, Unsigned, IEEEFloat, IEEEDouble + } +} diff --git a/DbcParserLib/Parsers/MessageLineParser.cs b/DbcParserLib/Parsers/MessageLineParser.cs index dfc168f..090f34a 100644 --- a/DbcParserLib/Parsers/MessageLineParser.cs +++ b/DbcParserLib/Parsers/MessageLineParser.cs @@ -17,7 +17,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin var match = Regex.Match(line, MessageRegex); if(match.Success) { - var msg = new Message() + var msg = new EditableMessage() { Name = match.Groups[2].Value, DLC = byte.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture), diff --git a/DbcParserLib/Parsers/NodeLineParser.cs b/DbcParserLib/Parsers/NodeLineParser.cs index d3c018d..241a6f0 100644 --- a/DbcParserLib/Parsers/NodeLineParser.cs +++ b/DbcParserLib/Parsers/NodeLineParser.cs @@ -14,7 +14,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin foreach(var nodeName in line.SplitBySpace().Skip(1)) { - var node = new Node() + var node = new EditableNode() { Name = nodeName }; diff --git a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs index 1223391..37bbc26 100644 --- a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs @@ -1,5 +1,6 @@ using DbcParserLib.Model; using System; +using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Text.RegularExpressions; @@ -10,8 +11,8 @@ public class PropertiesDefinitionLineParser : ILineParser { private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; - private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([0-9.]+)\s+([0-9.]+))|(STRING)|(ENUM\s+(?:""[^""]*"",*){1,100}))\s*;"; - private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(-?\d+|[0-9.]+|""[^""]*"")\s*;"; + private const string PropertyDefinitionParsingRegex = @"BA_DEF_\s+(?:(BU_|BO_|SG_|EV_)\s+)?""([a-zA-Z_][\w]*)""\s+(?:(?:(INT|HEX)\s+(-?\d+)\s+(-?\d+))|(?:(FLOAT)\s+([\d\+\-eE.]+)\s+([\d\+\-eE.]+))|(STRING)|(ENUM\s+(?:""[^""]*"",*){1,100}))\s*;"; + private const string PropertyDefinitionDefaultParsingRegex = @"BA_DEF_DEF_\s+""([a-zA-Z_][\w]*)""\s+(-?\d+|[\d\+\-eE.]+|""[^""]*"")\s*;"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { @@ -81,7 +82,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin var enumDefinition = match.Groups[10].Value.Replace("\"", "").Split(' ')[1]; customProperty.EnumCustomProperty = new EnumCustomPropertyDefinition { - Definition = enumDefinition.Split(','), + Values = enumDefinition.Split(','), }; } customProperty.DataType = dataType; diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index 9922f4a..9d863ce 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -9,7 +9,7 @@ namespace DbcParserLib.Parsers public class PropertiesLineParser : ILineParser { private const string PropertiesLineStarter = "BA_ "; - private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(-?\d+|[0-9.]+|""[^""]*"");"; + private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(-?\d+|[\d\+\-eE.]+|""[^""]*"");"; public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { diff --git a/DbcParserLib/Parsers/SignalLineParser.cs b/DbcParserLib/Parsers/SignalLineParser.cs index 845e737..f864d98 100644 --- a/DbcParserLib/Parsers/SignalLineParser.cs +++ b/DbcParserLib/Parsers/SignalLineParser.cs @@ -52,7 +52,7 @@ private static void AddSignal(string line, IDbcBuilder builder) if (records.Length < 10) return; - var sig = new Signal(); + var sig = new EditableSignal(); if (records[2] != ":") // signal is multiplexed { muxOffset = 1; @@ -89,7 +89,7 @@ private static void AddSignalRegex(string line, IDbcBuilder builder) if (match.Success == false) return; var factorStr = match.Groups[7].Value; - var sig = new Signal + var sig = new EditableSignal { Multiplexing = match.Groups[2].Value, Name = match.Groups[1].Value, From 02d4581da7de945e3af6d65a1b3d1d396f16b727 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Mon, 27 Feb 2023 23:50:08 +0100 Subject: [PATCH 8/9] Changed classes visibility - Editable classes (Message, Node, Signal) are now internal - LineParser classes are now internal - ILineParser and IDbcBuilder interfaces are now internal --- DbcParserLib/Dbc.cs | 3 +++ DbcParserLib/DbcBuilder.cs | 2 +- DbcParserLib/IDbcBuilder.cs | 2 +- DbcParserLib/Model/Message.cs | 3 +-- DbcParserLib/Model/Node.cs | 2 +- DbcParserLib/Model/Signal.cs | 2 +- DbcParserLib/Parsers/CommentLineParser.cs | 2 +- DbcParserLib/Parsers/ILineParser.cs | 2 +- DbcParserLib/Parsers/IgnoreLineParser.cs | 2 +- DbcParserLib/Parsers/MessageLineParser.cs | 2 +- DbcParserLib/Parsers/NodeLineParser.cs | 2 +- DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs | 2 +- DbcParserLib/Parsers/PropertiesLineParser.cs | 2 +- DbcParserLib/Parsers/SignalLineParser.cs | 2 +- DbcParserLib/Parsers/SignalValueTypeLineParser.cs | 2 +- DbcParserLib/Parsers/UnknownLineParser.cs | 2 +- DbcParserLib/Parsers/ValueTableLineParser.cs | 2 +- 17 files changed, 19 insertions(+), 17 deletions(-) diff --git a/DbcParserLib/Dbc.cs b/DbcParserLib/Dbc.cs index c630091..1d16a60 100644 --- a/DbcParserLib/Dbc.cs +++ b/DbcParserLib/Dbc.cs @@ -1,6 +1,9 @@ using System.Collections.Generic; using DbcParserLib.Model; +using System.Runtime.CompilerServices; +[assembly: InternalsVisibleTo("DbcParserLib.Tests")] +[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] namespace DbcParserLib { public class Dbc diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index 5c65724..d8a40eb 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -13,7 +13,7 @@ internal class ValuesTable public string ValueTable { get; set; } } - public class DbcBuilder : IDbcBuilder + internal class DbcBuilder : IDbcBuilder { private readonly ISet m_nodes = new HashSet(new NodeEqualityComparer()); private readonly IDictionary m_namedTablesMap = new Dictionary(); diff --git a/DbcParserLib/IDbcBuilder.cs b/DbcParserLib/IDbcBuilder.cs index d935b2a..b53ec25 100644 --- a/DbcParserLib/IDbcBuilder.cs +++ b/DbcParserLib/IDbcBuilder.cs @@ -3,7 +3,7 @@ namespace DbcParserLib { - public interface IDbcBuilder + internal interface IDbcBuilder { void AddMessage(EditableMessage message); void AddMessageComment(uint messageId, string comment); diff --git a/DbcParserLib/Model/Message.cs b/DbcParserLib/Model/Message.cs index 0c5d8a0..c59ef3e 100644 --- a/DbcParserLib/Model/Message.cs +++ b/DbcParserLib/Model/Message.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Collections.Immutable; using System.Text; namespace DbcParserLib.Model @@ -31,7 +30,7 @@ internal Message(EditableMessage message, IReadOnlyList signals) } } - public class EditableMessage + internal class EditableMessage { public uint ID; public bool IsExtID; diff --git a/DbcParserLib/Model/Node.cs b/DbcParserLib/Model/Node.cs index e2b2241..f6ad6a6 100644 --- a/DbcParserLib/Model/Node.cs +++ b/DbcParserLib/Model/Node.cs @@ -18,7 +18,7 @@ internal Node(EditableNode node) } } - public class EditableNode + internal class EditableNode { public string Name; public string Comment; diff --git a/DbcParserLib/Model/Signal.cs b/DbcParserLib/Model/Signal.cs index 372336a..aa84812 100644 --- a/DbcParserLib/Model/Signal.cs +++ b/DbcParserLib/Model/Signal.cs @@ -55,7 +55,7 @@ internal Signal(EditableSignal signal) } } - public class EditableSignal + internal class EditableSignal { private DbcValueType m_ValueType = DbcValueType.Signed; diff --git a/DbcParserLib/Parsers/CommentLineParser.cs b/DbcParserLib/Parsers/CommentLineParser.cs index 0332e15..c6a3046 100644 --- a/DbcParserLib/Parsers/CommentLineParser.cs +++ b/DbcParserLib/Parsers/CommentLineParser.cs @@ -6,7 +6,7 @@ namespace DbcParserLib.Parsers { - public class CommentLineParser : ILineParser + internal class CommentLineParser : ILineParser { private const string CommentLineStarter = "CM_ "; private const string NodeParsingRegex = @"CM_ BU_\s+([a-zA-Z_][\w]*)\s+""*([^""]*)""*\s*;"; diff --git a/DbcParserLib/Parsers/ILineParser.cs b/DbcParserLib/Parsers/ILineParser.cs index 6427729..1f0bc83 100644 --- a/DbcParserLib/Parsers/ILineParser.cs +++ b/DbcParserLib/Parsers/ILineParser.cs @@ -1,6 +1,6 @@ namespace DbcParserLib.Parsers { - public interface ILineParser + internal interface ILineParser { bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider); } diff --git a/DbcParserLib/Parsers/IgnoreLineParser.cs b/DbcParserLib/Parsers/IgnoreLineParser.cs index c47f163..859b5b9 100644 --- a/DbcParserLib/Parsers/IgnoreLineParser.cs +++ b/DbcParserLib/Parsers/IgnoreLineParser.cs @@ -1,6 +1,6 @@ namespace DbcParserLib.Parsers { - public class IgnoreLineParser : ILineParser + internal class IgnoreLineParser : ILineParser { public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { diff --git a/DbcParserLib/Parsers/MessageLineParser.cs b/DbcParserLib/Parsers/MessageLineParser.cs index 090f34a..3407523 100644 --- a/DbcParserLib/Parsers/MessageLineParser.cs +++ b/DbcParserLib/Parsers/MessageLineParser.cs @@ -4,7 +4,7 @@ namespace DbcParserLib.Parsers { - public class MessageLineParser : ILineParser + internal class MessageLineParser : ILineParser { private const string MessageLineStarter = "BO_ "; private const string MessageRegex = @"BO_ (\d+)\s+(\w+)\s*:\s*(\d+)\s+(\w+)"; diff --git a/DbcParserLib/Parsers/NodeLineParser.cs b/DbcParserLib/Parsers/NodeLineParser.cs index 241a6f0..ae2825d 100644 --- a/DbcParserLib/Parsers/NodeLineParser.cs +++ b/DbcParserLib/Parsers/NodeLineParser.cs @@ -3,7 +3,7 @@ namespace DbcParserLib.Parsers { - public class NodeLineParser : ILineParser + internal class NodeLineParser : ILineParser { private const string NodeLineStarter = "BU_:"; diff --git a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs index 37bbc26..be78eff 100644 --- a/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesDefinitionLineParser.cs @@ -7,7 +7,7 @@ namespace DbcParserLib.Parsers { - public class PropertiesDefinitionLineParser : ILineParser + internal class PropertiesDefinitionLineParser : ILineParser { private const string PropertiesDefinitionLineStarter = "BA_DEF_ "; private const string PropertiesDefinitionDefaultLineStarter = "BA_DEF_DEF_ "; diff --git a/DbcParserLib/Parsers/PropertiesLineParser.cs b/DbcParserLib/Parsers/PropertiesLineParser.cs index 9d863ce..1159edb 100644 --- a/DbcParserLib/Parsers/PropertiesLineParser.cs +++ b/DbcParserLib/Parsers/PropertiesLineParser.cs @@ -6,7 +6,7 @@ namespace DbcParserLib.Parsers { - public class PropertiesLineParser : ILineParser + internal class PropertiesLineParser : ILineParser { private const string PropertiesLineStarter = "BA_ "; private const string PropertyParsingRegex = @"BA_\s+""([a-zA-Z_][\w]*)""(?:\s+(?:(BU_|EV_)\s+([a-zA-Z_][\w]*))|\s+(?:(BO_)\s+(\d+))|\s+(?:(SG_)\s+(\d+)\s+([a-zA-Z_][\w]*)))?\s+(-?\d+|[\d\+\-eE.]+|""[^""]*"");"; diff --git a/DbcParserLib/Parsers/SignalLineParser.cs b/DbcParserLib/Parsers/SignalLineParser.cs index f864d98..80733f1 100644 --- a/DbcParserLib/Parsers/SignalLineParser.cs +++ b/DbcParserLib/Parsers/SignalLineParser.cs @@ -6,7 +6,7 @@ namespace DbcParserLib.Parsers { - public class SignalLineParser : ILineParser + internal class SignalLineParser : ILineParser { private delegate void ParsingStrategy(string line, IDbcBuilder builder); diff --git a/DbcParserLib/Parsers/SignalValueTypeLineParser.cs b/DbcParserLib/Parsers/SignalValueTypeLineParser.cs index d4c78b6..1ebf482 100644 --- a/DbcParserLib/Parsers/SignalValueTypeLineParser.cs +++ b/DbcParserLib/Parsers/SignalValueTypeLineParser.cs @@ -3,7 +3,7 @@ namespace DbcParserLib.Parsers { - public class SignalValueTypeLineParser : ILineParser + internal class SignalValueTypeLineParser : ILineParser { private const string SignalValueTypeStarter = "SIG_VALTYPE_ "; diff --git a/DbcParserLib/Parsers/UnknownLineParser.cs b/DbcParserLib/Parsers/UnknownLineParser.cs index 7149e6a..636b263 100644 --- a/DbcParserLib/Parsers/UnknownLineParser.cs +++ b/DbcParserLib/Parsers/UnknownLineParser.cs @@ -1,6 +1,6 @@ namespace DbcParserLib.Parsers { - public class UnknownLineParser : ILineParser + internal class UnknownLineParser : ILineParser { public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLineProvider) { diff --git a/DbcParserLib/Parsers/ValueTableLineParser.cs b/DbcParserLib/Parsers/ValueTableLineParser.cs index fb28f68..c71a6f5 100644 --- a/DbcParserLib/Parsers/ValueTableLineParser.cs +++ b/DbcParserLib/Parsers/ValueTableLineParser.cs @@ -7,7 +7,7 @@ namespace DbcParserLib.Parsers { - public class ValueTableLineParser : ILineParser + internal class ValueTableLineParser : ILineParser { private const string ValueTableLineStarter = "VAL_"; From ec15a55dd3c54ba1c5c71badd379decea089a8c3 Mon Sep 17 00:00:00 2001 From: Federico Panzani Date: Thu, 9 Mar 2023 09:03:50 +0100 Subject: [PATCH 9/9] Immutable classes not used anymore (but ready to use) - Final immutable objects are now immutable classes (eg: Node -> ImmutableNode) - Mutable classes are now final objects (eg: MutableNode -> Node) - Immutable classes are not used anymore (ready to be implemented in the future) --- DbcParserLib.Tests/DbcBuilderTests.cs | 78 +++++++++---------- DbcParserLib.Tests/ExtensionMethodsTests.cs | 56 ++++++------- DbcParserLib.Tests/MessageLineParserTests.cs | 8 +- DbcParserLib.Tests/NodeLineParserTests.cs | 4 +- DbcParserLib.Tests/PackerTests.cs | 68 ++++++++-------- .../PropertiesLineParserTests.cs | 16 ++-- DbcParserLib.Tests/SignalLineParserTests.cs | 16 ++-- DbcParserLib/DbcBuilder.cs | 38 ++++----- DbcParserLib/IDbcBuilder.cs | 6 +- DbcParserLib/Model/Message.cs | 23 +++--- DbcParserLib/Model/Node.cs | 17 ++-- DbcParserLib/Model/Signal.cs | 17 ++-- DbcParserLib/Parsers/MessageLineParser.cs | 2 +- DbcParserLib/Parsers/NodeLineParser.cs | 2 +- DbcParserLib/Parsers/SignalLineParser.cs | 4 +- 15 files changed, 173 insertions(+), 182 deletions(-) diff --git a/DbcParserLib.Tests/DbcBuilderTests.cs b/DbcParserLib.Tests/DbcBuilderTests.cs index 97651e9..c0b755b 100644 --- a/DbcParserLib.Tests/DbcBuilderTests.cs +++ b/DbcParserLib.Tests/DbcBuilderTests.cs @@ -37,7 +37,7 @@ public void NoInteractionProduceAnEmptyDbc() public void SingleNodeIsAdded() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "nodeName" }; + var node = new Node { Name = "nodeName" }; builder.AddNode(node); var dbc = builder.Build(); @@ -50,9 +50,9 @@ public void SingleNodeIsAdded() public void DuplicatedNodesAreSkipped() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "nodeName" }; - var node2 = new EditableNode { Name = "nodeName2" }; - var node3 = new EditableNode { Name = "nodeName" }; + var node = new Node { Name = "nodeName" }; + var node2 = new Node { Name = "nodeName2" }; + var node3 = new Node { Name = "nodeName" }; builder.AddNode(node); builder.AddNode(node2); builder.AddNode(node3); @@ -68,7 +68,7 @@ public void DuplicatedNodesAreSkipped() public void NodeCommentIsAddedToNode() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "nodeName" }; + var node = new Node { Name = "nodeName" }; builder.AddNode(node); builder.AddNodeComment("nodeName", "this is a comment"); @@ -83,7 +83,7 @@ public void NodeCommentIsAddedToNode() public void NodeCommentIsSkippedIfNodeIsNotFound() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "nodeName" }; + var node = new Node { Name = "nodeName" }; builder.AddNode(node); builder.AddNodeComment("anotherNodeName", "this is a comment"); @@ -98,7 +98,7 @@ public void NodeCommentIsSkippedIfNodeIsNotFound() public void MessageIsAdded() { var builder = new DbcBuilder(); - var message = new EditableMessage { }; + var message = new Message { }; builder.AddMessage(message); var dbc = builder.Build(); @@ -110,7 +110,7 @@ public void MessageIsAdded() public void CommentIsAddedToMessage() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); builder.AddMessageComment(234, "comment"); var dbc = builder.Build(); @@ -125,7 +125,7 @@ public void CommentIsAddedToMessage() public void CommentIsNotAddedToMissingMessage() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); builder.AddMessageComment(235, "comment"); var dbc = builder.Build(); @@ -140,19 +140,19 @@ public void CommentIsNotAddedToMissingMessage() public void SignalIsAddedToCurrentMessage() { var builder = new DbcBuilder(); - var message1 = new EditableMessage { ID = 234 }; + var message1 = new Message { ID = 234 }; builder.AddMessage(message1); - var signal1 = new EditableSignal { Name = "name1" }; + var signal1 = new Signal { Name = "name1" }; builder.AddSignal(signal1); - var message2 = new EditableMessage { ID = 235 }; + var message2 = new Message { ID = 235 }; builder.AddMessage(message2); - var signal2 = new EditableSignal { Name = "name2" }; + var signal2 = new Signal { Name = "name2" }; builder.AddSignal(signal2); - var signal3 = new EditableSignal { Name = "name3" }; + var signal3 = new Signal { Name = "name3" }; builder.AddSignal(signal3); var dbc = builder.Build(); @@ -175,7 +175,7 @@ public void SignalIsAddedToCurrentMessage() public void SignalIsNotAddedIfNoMessageHasBeenProvidedFirst() { var builder = new DbcBuilder(); - builder.AddSignal(new EditableSignal { }); + builder.AddSignal(new Signal { }); var dbc = builder.Build(); Assert.IsEmpty(dbc.Nodes); @@ -186,9 +186,9 @@ public void SignalIsNotAddedIfNoMessageHasBeenProvidedFirst() public void CommentIsAddedToSignal() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(234, "name1", "comment"); @@ -205,9 +205,9 @@ public void CommentIsAddedToSignal() public void CommentIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(235, "name1", "comment"); @@ -224,9 +224,9 @@ public void CommentIsNotAddedToMissingSignalMessageId() public void CommentIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); builder.AddSignalComment(234, "name2", "comment"); @@ -243,9 +243,9 @@ public void CommentIsNotAddedToMissingSignalName() public void TableValuesAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -264,10 +264,10 @@ public void TableValuesAreAddedToSignal() public void TableValuesWithExtendedMessageIdAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 2566896411 }; + var message = new Message { ID = 2566896411 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -286,9 +286,9 @@ public void TableValuesWithExtendedMessageIdAreAddedToSignal() public void TableValueIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -307,9 +307,9 @@ public void TableValueIsNotAddedToMissingSignalMessageId() public void TableValueIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -328,9 +328,9 @@ public void TableValueIsNotAddedToMissingSignalName() public void NamedTableValuesAreAddedToSignal() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -351,9 +351,9 @@ public void NamedTableValuesAreAddedToSignal() public void NamedTableValueIsNotAddedToMissingSignalMessageId() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -374,9 +374,9 @@ public void NamedTableValueIsNotAddedToMissingSignalMessageId() public void NamedTableValueIsNotAddedToMissingSignalName() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake" } }; @@ -397,9 +397,9 @@ public void NamedTableValueIsNotAddedToMissingSignalName() public void NamedTableValueIsNotAddedIfTableNameDoesNotExist() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); builder.LinkNamedTableToSignal(234, "name1", "aTableName"); @@ -446,9 +446,9 @@ public void NamedTablesWithSameNameAreManaged() public void NamedTablesWithSameNameOverridesPrevious() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 234 }; + var message = new Message { ID = 234 }; builder.AddMessage(message); - var signal = new EditableSignal { Name = "name1" }; + var signal = new Signal { Name = "name1" }; builder.AddSignal(signal); var testValuesDict = new Dictionary() { { 1, "fake1" } }; var testValuesDict2 = new Dictionary() { { 2, "fake2" } }; diff --git a/DbcParserLib.Tests/ExtensionMethodsTests.cs b/DbcParserLib.Tests/ExtensionMethodsTests.cs index d689117..7139888 100644 --- a/DbcParserLib.Tests/ExtensionMethodsTests.cs +++ b/DbcParserLib.Tests/ExtensionMethodsTests.cs @@ -10,40 +10,40 @@ public class ExtensionMethodsTests [Test] public void MotorolaTest() { - var sig = new EditableSignal + var sig = new Signal { ByteOrder = 0, // 0 = Big Endian (Motorola), 1 = Little Endian (Intel) }; - Assert.IsTrue(sig.CreateSignal().Motorola()); - Assert.IsTrue(sig.CreateSignal().Msb()); - Assert.IsFalse(sig.CreateSignal().Intel()); - Assert.IsFalse(sig.CreateSignal().Lsb()); + Assert.IsTrue(sig.Motorola()); + Assert.IsTrue(sig.Msb()); + Assert.IsFalse(sig.Intel()); + Assert.IsFalse(sig.Lsb()); } [Test] public void IntelTest() { - var sig = new EditableSignal + var sig = new Signal { ByteOrder = 1, // 0 = Big Endian (Motorola), 1 = Little Endian (Intel) }; - Assert.IsFalse(sig.CreateSignal().Motorola()); - Assert.IsFalse(sig.CreateSignal().Msb()); - Assert.IsTrue(sig.CreateSignal().Intel()); - Assert.IsTrue(sig.CreateSignal().Lsb()); + Assert.IsFalse(sig.Motorola()); + Assert.IsFalse(sig.Msb()); + Assert.IsTrue(sig.Intel()); + Assert.IsTrue(sig.Lsb()); } [Test] public void NoMultiplexingTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = null, }; - var multiplexing = sig.CreateSignal().MultiplexingInfo(); + var multiplexing = sig.MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.None, multiplexing.Role); Assert.AreEqual(0, multiplexing.Group); } @@ -51,12 +51,12 @@ public void NoMultiplexingTest() [Test] public void MultiplexorTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = "M", }; - var multiplexing = sig.CreateSignal().MultiplexingInfo(); + var multiplexing = sig.MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexor, multiplexing.Role); Assert.AreEqual(0, multiplexing.Group); } @@ -64,12 +64,12 @@ public void MultiplexorTest() [Test] public void MultiplexedSingleDigitTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = "m3", }; - var multiplexing = sig.CreateSignal().MultiplexingInfo(); + var multiplexing = sig.MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(3, multiplexing.Group); } @@ -77,12 +77,12 @@ public void MultiplexedSingleDigitTest() [Test] public void ExtendedMultiplexingIsPartiallySupportedTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = "m3M", }; - var multiplexing = sig.CreateSignal().MultiplexingInfo(); + var multiplexing = sig.MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(3, multiplexing.Group); } @@ -90,12 +90,12 @@ public void ExtendedMultiplexingIsPartiallySupportedTest() [Test] public void MultiplexedDoubleDigitTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = "m12", }; - var multiplexing = sig.CreateSignal().MultiplexingInfo(); + var multiplexing = sig.MultiplexingInfo(); Assert.AreEqual(MultiplexingRole.Multiplexed, multiplexing.Role); Assert.AreEqual(12, multiplexing.Group); } @@ -103,36 +103,36 @@ public void MultiplexedDoubleDigitTest() [Test] public void MultiplexedMessageTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = "M", }; - var message = new EditableMessage(); + var message = new Message(); message.Signals.Add(sig); - Assert.IsTrue(message.CreateMessage().IsMultiplexed()); + Assert.IsTrue(message.IsMultiplexed()); } [Test] public void MessageWithNoMutiplexorIsNotMultiplexedTest() { - var sig = new EditableSignal + var sig = new Signal { Multiplexing = null, }; - var message = new EditableMessage(); + var message = new Message(); message.Signals.Add(sig); - Assert.IsFalse(message.CreateMessage().IsMultiplexed()); + Assert.IsFalse(message.IsMultiplexed()); } [Test] public void EmptyMessageIsNotMultiplexedTest() { - var message = new EditableMessage(); - Assert.IsFalse(message.CreateMessage().IsMultiplexed()); + var message = new Message(); + Assert.IsFalse(message.IsMultiplexed()); } } } \ No newline at end of file diff --git a/DbcParserLib.Tests/MessageLineParserTests.cs b/DbcParserLib.Tests/MessageLineParserTests.cs index 737df1b..5fee29a 100644 --- a/DbcParserLib.Tests/MessageLineParserTests.cs +++ b/DbcParserLib.Tests/MessageLineParserTests.cs @@ -71,8 +71,8 @@ public void MalformedLineIsAcceptedWithoutInteraction() public void FullLineIsParsed() { var dbcBuilderMock = m_repository.Create(); - dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) - .Callback(message => + dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) + .Callback(message => { Assert.AreEqual(1041, message.ID); Assert.AreEqual("DOORS_SEATBELTS", message.Name); @@ -91,8 +91,8 @@ public void FullLineIsParsed() public void FullLineWithSomeRamdomSpacesIsParsed() { var dbcBuilderMock = m_repository.Create(); - dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) - .Callback(message => + dbcBuilderMock.Setup(mock => mock.AddMessage(It.IsAny())) + .Callback(message => { Assert.AreEqual(1041, message.ID); Assert.AreEqual("DOORS_SEATBELTS", message.Name); diff --git a/DbcParserLib.Tests/NodeLineParserTests.cs b/DbcParserLib.Tests/NodeLineParserTests.cs index b0441a6..93c4830 100644 --- a/DbcParserLib.Tests/NodeLineParserTests.cs +++ b/DbcParserLib.Tests/NodeLineParserTests.cs @@ -78,8 +78,8 @@ public void FullLineIsParsed() }; var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddNode(It.IsAny())) - .Callback(node => + dbcBuilderMock.Setup(mock => mock.AddNode(It.IsAny())) + .Callback(node => { Assert.IsFalse(string.IsNullOrWhiteSpace(node.Name)); Assert.IsTrue(string.IsNullOrWhiteSpace(node.Comment)); diff --git a/DbcParserLib.Tests/PackerTests.cs b/DbcParserLib.Tests/PackerTests.cs index 70aa5d4..6f4d9d4 100644 --- a/DbcParserLib.Tests/PackerTests.cs +++ b/DbcParserLib.Tests/PackerTests.cs @@ -9,7 +9,7 @@ public class PackerTests [Test] public void SimplePackingTestSigned() { - var sig = new EditableSignal + var sig = new Signal { Length = 14, StartBit = 2, @@ -19,10 +19,10 @@ public void SimplePackingTestSigned() Offset = 20 }; - var txMsg = Packer.TxSignalPack(-34.3, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(-34.3, sig); Assert.AreEqual(43816, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(-34.3, val, 1e-2); } @@ -32,7 +32,7 @@ public void SimplePackingTestSigned() [TestCase((ushort)12, 13334048092160ul)] public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) { - var sig = new EditableSignal + var sig = new Signal { Length = 32, StartBit = start, @@ -43,10 +43,10 @@ public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) }; var expected = -34.3f; - var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(expected, sig); Assert.AreEqual(packet, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(expected, val, 1e-2); } @@ -56,7 +56,7 @@ public void FloatLittleEndianValuePackingTest(ushort start, ulong packet) [TestCase((ushort)12, 105991844730880ul)] public void FloatBigEndianValuePackingTest(ushort start, ulong packet) { - var sig = new EditableSignal + var sig = new Signal { Length = 32, StartBit = start, @@ -67,17 +67,17 @@ public void FloatBigEndianValuePackingTest(ushort start, ulong packet) }; var value = -34.3f; - var txMsg = Packer.TxSignalPack(value, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(value, sig); Assert.AreEqual(packet, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(value, val, 1e-2); } [Test] public void DoubleLittleEndianValuePackingTest() { - var sig = new EditableSignal + var sig = new Signal { Length = 64, StartBit = 0, @@ -88,17 +88,17 @@ public void DoubleLittleEndianValuePackingTest() }; var expected = -34.3567; - var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(expected, sig); Assert.AreEqual(13853404129830452697, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(expected, val, 1e-2); } [Test] public void DoubleBigEndianValuePackingTest() { - var sig = new EditableSignal + var sig = new Signal { Length = 64, StartBit = 7, @@ -109,17 +109,17 @@ public void DoubleBigEndianValuePackingTest() }; var expected = -34.35564; - var txMsg = Packer.TxSignalPack(expected, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(expected, sig); Assert.AreEqual(2419432028705210816, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(expected, val, 1e-2); } [Test] public void SimplePackingTestNonSigned() { - var sig = new EditableSignal + var sig = new Signal { Length = 16, StartBit = 24, @@ -129,20 +129,20 @@ public void SimplePackingTestNonSigned() Offset = 0 }; - var txMsg = Packer.TxSignalPack(800, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(800, sig); Assert.AreEqual(107374182400, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(800, val); - val = Packer.RxSignalUnpack(9655716608953581040, sig.CreateSignal()); + val = Packer.RxSignalUnpack(9655716608953581040, sig); Assert.AreEqual(800, val); } [Test] public void PackingTest64Bit() { - var sig = new EditableSignal + var sig = new Signal { Length = 64, StartBit = 0, @@ -152,10 +152,10 @@ public void PackingTest64Bit() Offset = 0 }; - var txMsg = Packer.TxSignalPack(396.31676720860366, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(396.31676720860366, sig); Assert.AreEqual(3963167672086036480, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(396.31676720860366, val); } @@ -163,7 +163,7 @@ public void PackingTest64Bit() [Test] public void UnPackingTestMultipleUnpacks() { - var sig = new EditableSignal + var sig = new Signal { Length = 8, StartBit = 56, @@ -173,13 +173,13 @@ public void UnPackingTestMultipleUnpacks() Offset = -125 }; - var txMsg = Packer.TxSignalPack(8, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(8, sig); Assert.AreEqual(9583660007044415488, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(8, val); - val = Packer.RxSignalUnpack(9655716608953581040, sig.CreateSignal()); + val = Packer.RxSignalUnpack(9655716608953581040, sig); Assert.AreEqual(8, val); } @@ -187,7 +187,7 @@ public void UnPackingTestMultipleUnpacks() [Test] public void BitPackingTest1() { - var sig = new EditableSignal + var sig = new Signal { Length = 1, StartBit = 18, @@ -197,13 +197,13 @@ public void BitPackingTest1() Offset = 0 }; - var txMsg = Packer.TxSignalPack(1, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(1, sig); Assert.AreEqual(262144, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(1, val); - val = Packer.RxSignalUnpack(140737488617472, sig.CreateSignal()); + val = Packer.RxSignalUnpack(140737488617472, sig); Assert.AreEqual(1, val); } @@ -211,7 +211,7 @@ public void BitPackingTest1() [Test] public void BitPackingTest2() { - var sig = new EditableSignal + var sig = new Signal { Length = 3, StartBit = 6, @@ -221,13 +221,13 @@ public void BitPackingTest2() Offset = 0 }; - var txMsg = Packer.TxSignalPack(6, sig.CreateSignal()); + var txMsg = Packer.TxSignalPack(6, sig); Assert.AreEqual(384, txMsg); - var val = Packer.RxSignalUnpack(txMsg, sig.CreateSignal()); + var val = Packer.RxSignalUnpack(txMsg, sig); Assert.AreEqual(6, val); - val = Packer.RxSignalUnpack(498806260540323729, sig.CreateSignal()); + val = Packer.RxSignalUnpack(498806260540323729, sig); Assert.AreEqual(6, val); } } diff --git a/DbcParserLib.Tests/PropertiesLineParserTests.cs b/DbcParserLib.Tests/PropertiesLineParserTests.cs index c9e6af5..59bfd9c 100644 --- a/DbcParserLib.Tests/PropertiesLineParserTests.cs +++ b/DbcParserLib.Tests/PropertiesLineParserTests.cs @@ -109,7 +109,7 @@ public void EnumDefinitionCustomPropertyIsParsedTest() public void MsgCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 2394947585 }; + var message = new Message { ID = 2394947585 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); @@ -127,10 +127,10 @@ public void MsgCustomPropertyIsParsedTest() public void SigCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var message = new EditableMessage { ID = 2394947585 }; + var message = new Message { ID = 2394947585 }; message.IsExtID = DbcBuilder.IsExtID(ref message.ID); builder.AddMessage(message); - var signal = new EditableSignal { Name = "sig_name" }; + var signal = new Signal { Name = "sig_name" }; builder.AddSignal(signal); var sigInitialValueLineParser = CreateParser(); @@ -147,7 +147,7 @@ public void SigCustomPropertyIsParsedTest() public void NodeCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "Node1" }; + var node = new Node { Name = "Node1" }; builder.AddNode(node); var sigInitialValueLineParser = CreateParser(); @@ -161,7 +161,7 @@ public void NodeCustomPropertyIsParsedTest() public void NodeScientificNotationCustomPropertyIsParsedTest() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "Node1" }; + var node = new Node { Name = "Node1" }; builder.AddNode(node); var dbc = builder.Build(); @@ -177,7 +177,7 @@ public void NodeScientificNotationCustomPropertyIsParsedTest() public void NodeMultipleCustomPropertyAreParsedTest() { var builder = new DbcBuilder(); - var node = new EditableNode { Name = "Node1" }; + var node = new Node { Name = "Node1" }; builder.AddNode(node); var sigInitialValueLineParser = CreateParser(); @@ -199,8 +199,8 @@ public void NodeMultipleCustomPropertyAreParsedTest() public void CustomPropertyIsAssignedToDifferentNodesTest() { var builder = new DbcBuilder(); - var node1 = new EditableNode { Name = "Node1" }; - var node2 = new EditableNode { Name = "Node2" }; + var node1 = new Node { Name = "Node1" }; + var node2 = new Node { Name = "Node2" }; builder.AddNode(node1); builder.AddNode(node2); diff --git a/DbcParserLib.Tests/SignalLineParserTests.cs b/DbcParserLib.Tests/SignalLineParserTests.cs index 725b407..4ecc4b2 100644 --- a/DbcParserLib.Tests/SignalLineParserTests.cs +++ b/DbcParserLib.Tests/SignalLineParserTests.cs @@ -75,8 +75,8 @@ public void FullLineIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -104,8 +104,8 @@ public void FullLineMultiplexedIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -133,8 +133,8 @@ public void FullLineMultipleReceiversIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); @@ -163,8 +163,8 @@ public void FullLineMultipleReceiversWithSpacesIsParsed() var dbcBuilderMock = m_repository.Create(); var results = new List(); - dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) - .Callback(signal => + dbcBuilderMock.Setup(mock => mock.AddSignal(It.IsAny())) + .Callback(signal => { Assert.AreEqual("MCU_longitude", signal.Name); Assert.AreEqual(28, signal.StartBit); diff --git a/DbcParserLib/DbcBuilder.cs b/DbcParserLib/DbcBuilder.cs index d8a40eb..0497173 100644 --- a/DbcParserLib/DbcBuilder.cs +++ b/DbcParserLib/DbcBuilder.cs @@ -15,31 +15,31 @@ internal class ValuesTable internal class DbcBuilder : IDbcBuilder { - private readonly ISet m_nodes = new HashSet(new NodeEqualityComparer()); + private readonly ISet m_nodes = new HashSet(new NodeEqualityComparer()); private readonly IDictionary m_namedTablesMap = new Dictionary(); - private readonly IDictionary m_messages = new Dictionary(); - private readonly IDictionary> m_signals = new Dictionary>(); + private readonly IDictionary m_messages = new Dictionary(); + private readonly IDictionary> m_signals = new Dictionary>(); private readonly IDictionary> m_customProperties = new Dictionary>() { {DbcObjectType.Node, new Dictionary()}, {DbcObjectType.Message, new Dictionary()}, {DbcObjectType.Signal, new Dictionary()}, }; - private EditableMessage m_currentMessage; + private Message m_currentMessage; - public void AddNode(EditableNode node) + public void AddNode(Node node) { m_nodes.Add(node); } - public void AddMessage(EditableMessage message) + public void AddMessage(Message message) { m_messages[message.ID] = message; m_currentMessage = message; - m_signals[message.ID] = new Dictionary(); + m_signals[message.ID] = new Dictionary(); } - public void AddSignal(EditableSignal signal) + public void AddSignal(Signal signal) { if (m_currentMessage != null) { @@ -195,7 +195,7 @@ public void LinkNamedTableToSignal(uint messageId, string signalName, string tab } } - private bool TryGetValueMessageSignal(uint messageId, string signalName, out EditableSignal signal) + private bool TryGetValueMessageSignal(uint messageId, string signalName, out Signal signal) { if (m_signals.TryGetValue(messageId, out var signals) && signals.TryGetValue(signalName, out signal)) { @@ -266,25 +266,13 @@ public Dbc Build() message.Value.Signals.AddRange(m_signals[message.Key].Values); } - var nodes = new List(); - foreach (var node in m_nodes) - { - nodes.Add(node.CreateNode()); - } - - var messages = new List(); - foreach (var message in m_messages.Values) - { - messages.Add(message.CreateMessage()); - } - - return new Dbc(nodes, messages); + return new Dbc(m_nodes.ToArray(), m_messages.Values.ToArray()); } } -internal class NodeEqualityComparer : IEqualityComparer +internal class NodeEqualityComparer : IEqualityComparer { - public bool Equals(EditableNode b1, EditableNode b2) + public bool Equals(Node b1, Node b2) { if (b2 == null && b1 == null) return true; @@ -296,7 +284,7 @@ public bool Equals(EditableNode b1, EditableNode b2) return false; } - public int GetHashCode(EditableNode bx) + public int GetHashCode(Node bx) { return bx.Name.GetHashCode(); } diff --git a/DbcParserLib/IDbcBuilder.cs b/DbcParserLib/IDbcBuilder.cs index b53ec25..b5b5aab 100644 --- a/DbcParserLib/IDbcBuilder.cs +++ b/DbcParserLib/IDbcBuilder.cs @@ -5,13 +5,13 @@ namespace DbcParserLib { internal interface IDbcBuilder { - void AddMessage(EditableMessage message); + void AddMessage(Message message); void AddMessageComment(uint messageId, string comment); void AddMessageCycleTime(uint messageId, int cycleTime); void AddNamedValueTable(string name, IReadOnlyDictionary dictValues, string stringValues); - void AddNode(EditableNode node); + void AddNode(Node node); void AddNodeComment(string nodeName, string comment); - void AddSignal(EditableSignal signal); + void AddSignal(Signal signal); void AddSignalComment(uint messageId, string signalName, string comment); void AddSignalInitialValue(uint messageId, string signalName, double initialValue); void AddSignalValueType(uint messageId, string signalName, DbcValueType valueType); diff --git a/DbcParserLib/Model/Message.cs b/DbcParserLib/Model/Message.cs index c59ef3e..99babbc 100644 --- a/DbcParserLib/Model/Message.cs +++ b/DbcParserLib/Model/Message.cs @@ -4,7 +4,7 @@ namespace DbcParserLib.Model { - public class Message + internal class ImmutableMessage { public uint ID { get; } public bool IsExtID { get; } @@ -13,10 +13,10 @@ public class Message public string Transmitter { get; } public string Comment { get; } public int CycleTime { get; } - public IReadOnlyList Signals; - public IReadOnlyDictionary CustomProperties; + public IReadOnlyList Signals { get; } + public IReadOnlyDictionary CustomProperties { get; } - internal Message(EditableMessage message, IReadOnlyList signals) + internal ImmutableMessage(Message message, IReadOnlyList signals) { ID = message.ID; IsExtID = message.IsExtID; @@ -26,11 +26,12 @@ internal Message(EditableMessage message, IReadOnlyList signals) Comment = message.Comment; CycleTime= message.CycleTime; Signals = signals; - CustomProperties = message.CustomProperties; + //TODO: remove explicit cast (CustomProperty in Message class should be Dictionary instead IDictionary) + CustomProperties = (IReadOnlyDictionary)message.CustomProperties; } } - internal class EditableMessage + public class Message { public uint ID; public bool IsExtID; @@ -39,17 +40,17 @@ internal class EditableMessage public string Transmitter; public string Comment; public int CycleTime; - public List Signals = new List(); - public Dictionary CustomProperties = new Dictionary(); + public List Signals = new List(); + public IDictionary CustomProperties = new Dictionary(); - public Message CreateMessage() + internal ImmutableMessage CreateMessage() { - var signals = new List(); + var signals = new List(); foreach(var signal in Signals) { signals.Add(signal.CreateSignal()); } - return new Message(this, signals); + return new ImmutableMessage(this, signals); } } } diff --git a/DbcParserLib/Model/Node.cs b/DbcParserLib/Model/Node.cs index f6ad6a6..8829400 100644 --- a/DbcParserLib/Model/Node.cs +++ b/DbcParserLib/Model/Node.cs @@ -4,29 +4,30 @@ namespace DbcParserLib.Model { - public class Node + internal class ImmutableNode { public string Name { get; } public string Comment { get; } - public IReadOnlyDictionary CustomProperties; + public IReadOnlyDictionary CustomProperties { get; } - internal Node(EditableNode node) + internal ImmutableNode(Node node) { Name = node.Name; Comment = node.Comment; - CustomProperties = node.CustomProperties; + //TODO: remove explicit cast (CustomProperty in Node class should be Dictionary instead IDictionary) + CustomProperties = (IReadOnlyDictionary)node.CustomProperties; } } - internal class EditableNode + public class Node { public string Name; public string Comment; - public Dictionary CustomProperties = new Dictionary(); + public IDictionary CustomProperties = new Dictionary(); - public Node CreateNode() + internal ImmutableNode CreateNode() { - return new Node(this); + return new ImmutableNode(this); } } } \ No newline at end of file diff --git a/DbcParserLib/Model/Signal.cs b/DbcParserLib/Model/Signal.cs index aa84812..74d955e 100644 --- a/DbcParserLib/Model/Signal.cs +++ b/DbcParserLib/Model/Signal.cs @@ -4,7 +4,7 @@ namespace DbcParserLib.Model { - public class Signal + internal class ImmutableSignal { public uint ID { get; } public string Name { get; } @@ -28,9 +28,9 @@ public class Signal public IReadOnlyDictionary ValueTableMap { get; } public string Comment { get; } public string Multiplexing { get; } - public readonly IReadOnlyDictionary CustomProperties; + public IReadOnlyDictionary CustomProperties { get; } - internal Signal(EditableSignal signal) + internal ImmutableSignal(Signal signal) { ID = signal.ID; Name = signal.Name; @@ -51,11 +51,12 @@ internal Signal(EditableSignal signal) ValueTableMap = signal.ValueTableMap; Comment = signal.Comment; Multiplexing = signal.Multiplexing; - CustomProperties = signal.CustomProperties; + //TODO: remove explicit cast (CustomProperty in Signal class should be Dictionary instead IDictionary) + CustomProperties = (IReadOnlyDictionary)signal.CustomProperties; } } - internal class EditableSignal + public class Signal { private DbcValueType m_ValueType = DbcValueType.Signed; @@ -91,7 +92,7 @@ public DbcValueType ValueType public IReadOnlyDictionary ValueTableMap { get; private set; } public string Comment; public string Multiplexing; - public readonly Dictionary CustomProperties = new Dictionary(); + public readonly IDictionary CustomProperties = new Dictionary(); internal void SetValueTable(IReadOnlyDictionary dictValues, string stringValues) { @@ -99,9 +100,9 @@ internal void SetValueTable(IReadOnlyDictionary dictValues, string ValueTable = stringValues; } - public Signal CreateSignal() + internal ImmutableSignal CreateSignal() { - return new Signal(this); + return new ImmutableSignal(this); } } diff --git a/DbcParserLib/Parsers/MessageLineParser.cs b/DbcParserLib/Parsers/MessageLineParser.cs index 3407523..0c660c6 100644 --- a/DbcParserLib/Parsers/MessageLineParser.cs +++ b/DbcParserLib/Parsers/MessageLineParser.cs @@ -17,7 +17,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin var match = Regex.Match(line, MessageRegex); if(match.Success) { - var msg = new EditableMessage() + var msg = new Message() { Name = match.Groups[2].Value, DLC = byte.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture), diff --git a/DbcParserLib/Parsers/NodeLineParser.cs b/DbcParserLib/Parsers/NodeLineParser.cs index ae2825d..d399b6a 100644 --- a/DbcParserLib/Parsers/NodeLineParser.cs +++ b/DbcParserLib/Parsers/NodeLineParser.cs @@ -14,7 +14,7 @@ public bool TryParse(string line, IDbcBuilder builder, INextLineProvider nextLin foreach(var nodeName in line.SplitBySpace().Skip(1)) { - var node = new EditableNode() + var node = new Node() { Name = nodeName }; diff --git a/DbcParserLib/Parsers/SignalLineParser.cs b/DbcParserLib/Parsers/SignalLineParser.cs index 80733f1..b523713 100644 --- a/DbcParserLib/Parsers/SignalLineParser.cs +++ b/DbcParserLib/Parsers/SignalLineParser.cs @@ -52,7 +52,7 @@ private static void AddSignal(string line, IDbcBuilder builder) if (records.Length < 10) return; - var sig = new EditableSignal(); + var sig = new Signal(); if (records[2] != ":") // signal is multiplexed { muxOffset = 1; @@ -89,7 +89,7 @@ private static void AddSignalRegex(string line, IDbcBuilder builder) if (match.Success == false) return; var factorStr = match.Groups[7].Value; - var sig = new EditableSignal + var sig = new Signal { Multiplexing = match.Groups[2].Value, Name = match.Groups[1].Value,