Merge pull request #75 from xcomponent/ISSUE-74

ISSUE-74 : Fix when parsing an XCApi containing different components with the same stateMachine name

Author: Julien-Molina

ReactiveXComponent/Configuration/XCApiTags.cs

@@ -15,6 +15,7 @@ public static class XCApiTags
         public const string EventCode = "eventCode";
         public const string ComponentCode = "componentCode";
         public const string StateMachineCode = "stateMachineCode";
+        public const string StateMachine = "stateMachine";
         public const string Topic = "topic";
         public const string Subscribe = "subscribe";
         public const string EventType = "eventType";

ReactiveXComponent/Parser/StateMachineInfo.cs

@@ -0,0 +1,14 @@
+namespace ReactiveXComponent.Parser
+{
+    public class StateMachineInfo
+    {
+        public string StateMachineName { get; }
+        public int StateMachineCode { get; }
+
+        public StateMachineInfo(string stateMachineName, int stateMachineCode)
+        {
+            StateMachineName = stateMachineName;
+            StateMachineCode = stateMachineCode;
+        }
+    }
+}

ReactiveXComponent/Parser/XCApiConfigParser.cs

@@ -11,55 +11,69 @@ namespace ReactiveXComponent.Parser
 {
     public class XCApiConfigParser : IXCApiConfigParser
     {
-        private XCApiDescription _xcApiDescription;
-
-        private Dictionary<string, int> _componentCodeByComponent;
-        private Dictionary<string, int> _stateMachineCodeByStateMachine;
-        private Dictionary<string, int> _eventCodeByEvent;
-        private Dictionary<TopicIdentifier, string> _publisherTopicByIdentifier;
-        private Dictionary<TopicIdentifier, string> _subscriberTopicByIdentifier;
-        private Dictionary<long, string> _snapshotTopicByComponent;
-
+        private XCApiDescription _xcApiDescription;
         private XNamespace _xc;
+        private Dictionary<string, int> _eventCodeByEventRepository;
+        private Dictionary<TopicIdentifier, string> _publisherTopicByIdentifierRepository;
+        private Dictionary<TopicIdentifier, string> _subscriberTopicByIdentifierRepository;
+        private Dictionary<long, string> _snapshotTopicByComponentRepository;
+        private readonly Dictionary<string, List<StateMachineInfo>> _stateMachineInfoByComponentRepository =
+            new Dictionary<string, List<StateMachineInfo>>();
+        private readonly Dictionary<string, int> _componentCodeByComponentNameRepository = new Dictionary<string, int>();
+
 
         public void Parse(Stream xcApiStream)
         {
             var reader = XmlReader.Create(xcApiStream);
             _xcApiDescription = new XCApiDescription(reader);
             _xc = "http://xcomponent.com/DeploymentConfig.xsd";
 
-            _componentCodeByComponent = CreateComponentCodeByNameRepository(_xcApiDescription.GetComponentsNode());
-            _stateMachineCodeByStateMachine = CreateStateMachineCodeByNameRepository(_xcApiDescription.GetStateMachinesNode());
-            _eventCodeByEvent = CreateEventCodeByEventRepository(_xcApiDescription.GetPublishersNode());
-            _publisherTopicByIdentifier = CreatePublisherTopicByComponentAndStateMachineRepository(_xcApiDescription.GetPublishersNode());
-            _subscriberTopicByIdentifier = CreateConsumerTopicByComponentAndStateMachineAndRepository(_xcApiDescription.GetConsumersNode());
-            _snapshotTopicByComponent = CreateSnapshotTopicByComponentRepository(_xcApiDescription.GetSnapshotsNode()); ;
+            ParseComponentNodes(_xcApiDescription.GetComponentsNode());
+            _eventCodeByEventRepository = CreateEventCodeByEventRepository(_xcApiDescription.GetPublishersNode());
+            _publisherTopicByIdentifierRepository =
+                CreatePublisherTopicByComponentAndStateMachineRepository(_xcApiDescription.GetPublishersNode());
+            _subscriberTopicByIdentifierRepository =
+                CreateConsumerTopicByComponentAndStateMachineRepository(_xcApiDescription.GetConsumersNode());
+            _snapshotTopicByComponentRepository = CreateSnapshotTopicByComponentRepository(_xcApiDescription.GetSnapshotsNode());
         }
 
-        private Dictionary<string, int> CreateComponentCodeByNameRepository(IEnumerable<XElement> components)
+        private void ParseComponentNodes(IEnumerable<XElement> components)
         {
-            Dictionary<string, int> componentCodeByNameRepo = new Dictionary<string, int>();
-
             foreach (XElement component in components)
             {
-                AddComponentToRepository(componentCodeByNameRepo, component);
+                var componentName = component.Attribute(XCApiTags.Name)?.Value;
+                var componentCode = component.Attribute(XCApiTags.Id)?.Value;
+
+                if (!string.IsNullOrEmpty(componentName) && !string.IsNullOrEmpty(componentCode))
+                {
+                    _componentCodeByComponentNameRepository.Add(componentName, Convert.ToInt32(componentCode));
+
+                    ParseStateMachineNodes(component, componentName);
+                }
             }
-            return componentCodeByNameRepo;
         }
 
-        private void AddComponentToRepository(Dictionary<string, int> repository, XElement component)
-        {
-            repository.Add(component.Attribute(XCApiTags.Name).Value, Convert.ToInt32(component.Attribute(XCApiTags.Id).Value));
-        }
-
-        private Dictionary<string, int> CreateStateMachineCodeByNameRepository(IEnumerable<XElement> stateMachines)
+        private void ParseStateMachineNodes(XElement component, string componentName)
         {
-            Dictionary<string, int> stateMachineCodeRepo = new Dictionary<string, int>();
-            foreach (XElement stateMachine in stateMachines)
+            if (_stateMachineInfoByComponentRepository.ContainsKey(componentName)) return;
+
+            var stateMachines = component.Descendants(_xc + XCApiTags.StateMachine);
+            var statemachineInfoList = new List<StateMachineInfo>
+                (
+                    stateMachines
+                        .Where(stateMachine => 
+                                !string.IsNullOrEmpty(stateMachine?.Attribute(XCApiTags.Name)?.Value)
+                                && !string.IsNullOrEmpty(stateMachine.Attribute(XCApiTags.Id)?.Value))
+                        .Select(stateMachine =>
+                            new StateMachineInfo(stateMachine.Attribute(XCApiTags.Name)?.Value, 
+                            Convert.ToInt32(stateMachine.Attribute(XCApiTags.Id)?.Value))
+                ).ToList()
+            );
+
+            if (statemachineInfoList.Any())
             {
-                stateMachineCodeRepo.Add(stateMachine.Attribute(XCApiTags.Name).Value, Convert.ToInt32(stateMachine.Attribute(XCApiTags.Id).Value));
+                _stateMachineInfoByComponentRepository.Add(componentName, statemachineInfoList);
             }
-            return stateMachineCodeRepo;
         }
 
         private Dictionary<string, int> CreateEventCodeByEventRepository(IEnumerable<XElement> publishNodes)
@@ -75,14 +89,19 @@ private Dictionary<string, int> CreateEventCodeByEventRepository(IEnumerable<XEl
 
         private void AddEventCodeToRepository(Dictionary<string, int> repository, XElement node)
         {
-            if (node?.Attribute(XCApiTags.EventName)?.Value != null && !repository.ContainsKey(node.Attribute(XCApiTags.EventName).Value))
+            var eventName = node?.Attribute(XCApiTags.EventName)?.Value;
+            var eventCode = node?.Attribute(XCApiTags.EventCode)?.Value;
+
+            if (!string.IsNullOrEmpty(eventName) 
+                && !repository.ContainsKey(eventName)
+                && !string.IsNullOrEmpty(eventCode))
             {
-                repository.Add(node.Attribute(XCApiTags.EventName).Value,
-                    Convert.ToInt32(node.Attribute(XCApiTags.EventCode).Value));
+                repository.Add(eventName, Convert.ToInt32(eventCode));
             }
         }
 
-        private Dictionary<TopicIdentifier, string> CreatePublisherTopicByComponentAndStateMachineRepository(IEnumerable<XElement> publishNodes)
+        private Dictionary<TopicIdentifier, string> CreatePublisherTopicByComponentAndStateMachineRepository(
+            IEnumerable<XElement> publishNodes)
         {
             Dictionary<TopicIdentifier, string> topicByIdentifierRepo = new Dictionary<TopicIdentifier, string>();
 
@@ -93,7 +112,8 @@ private Dictionary<TopicIdentifier, string> CreatePublisherTopicByComponentAndSt
             return topicByIdentifierRepo;
         }
 
-        private Dictionary<TopicIdentifier, string> CreateConsumerTopicByComponentAndStateMachineAndRepository(IEnumerable<XElement> subscribeNodes)
+        private Dictionary<TopicIdentifier, string> CreateConsumerTopicByComponentAndStateMachineRepository(
+            IEnumerable<XElement> subscribeNodes)
         {
             Dictionary<TopicIdentifier, string> topicByIdentifierRepo = new Dictionary<TopicIdentifier, string>();
 
@@ -109,67 +129,64 @@ private void AddTopicToRepository(Dictionary<TopicIdentifier, string> repository
             var componentCode = Convert.ToInt64(node?.Attribute(XCApiTags.ComponentCode)?.Value);
             var stateMachineCode = Convert.ToInt64(node?.Attribute(XCApiTags.StateMachineCode)?.Value);
             var topicType = node?.Attribute(XCApiTags.TopicType)?.Value;
-
+            var topicValue = node?.Descendants(_xc + XCApiTags.Topic).FirstOrDefault()?.Value;
             var topicIdentifier = new TopicIdentifier(componentCode, stateMachineCode, topicType);
-
-            if (!repository.ContainsKey(topicIdentifier))
+            
+            if (!repository.ContainsKey(topicIdentifier) && !string.IsNullOrEmpty(topicValue))
             {
-                repository.Add(topicIdentifier, node?.Descendants(_xc + XCApiTags.Topic).FirstOrDefault().Value);
+                repository.Add(topicIdentifier, topicValue);
             }
-        }
-
+        }
+
         private Dictionary<long, string> CreateSnapshotTopicByComponentRepository(IEnumerable<XElement> snapshotNodes)
         {
-            Dictionary<long, string> SnapshotTopicByComponentRepo = new Dictionary<long, string>();
-            foreach (XElement node in snapshotNodes)
+            var snapshotTopicByComponentRepo = new Dictionary<long, string>();
+            foreach (var node in snapshotNodes)
             {
-                AddSnapshotTopicToRepository(SnapshotTopicByComponentRepo, node);
+                AddSnapshotTopicToRepository(snapshotTopicByComponentRepo, node);
             }
-            return SnapshotTopicByComponentRepo;
+            return snapshotTopicByComponentRepo;
         }
 
-        private void AddSnapshotTopicToRepository(Dictionary<long, string> repository, XElement node)
+        private void AddSnapshotTopicToRepository(IDictionary<long, string> repository, XElement node)
         {
             var componentCode = Convert.ToInt64(node?.Attribute(XCApiTags.ComponentCode)?.Value);
-
-            if (!repository.ContainsKey(componentCode))
+            var snapshotTopic = node?.Descendants(_xc + XCApiTags.Topic).FirstOrDefault()?.Value;
+
+            if (!repository.ContainsKey(componentCode) && !string.IsNullOrEmpty(snapshotTopic))
             {
-                repository.Add(componentCode, node?.Descendants(_xc + XCApiTags.Topic).FirstOrDefault().Value);
+                repository.Add(componentCode, snapshotTopic);
             }
         }
 
         public string GetConnectionType()
         {
             var commmunicationNode = _xcApiDescription.GetCommunicationNode()?.FirstOrDefault();
 
-            if (commmunicationNode != null)
-            {
-                var communicationChildElements = commmunicationNode.Elements().ToList();
+            var communicationChildElements = commmunicationNode?.Elements().ToList();
 
-                if (communicationChildElements != null && communicationChildElements.Count == 1)
-                {
-                    var connection = communicationChildElements.FirstOrDefault();
-                    return connection.Name.LocalName;
-                }
+            if (communicationChildElements != null && communicationChildElements.Count == 1)
+            {
+                var connection = communicationChildElements.FirstOrDefault();
+                return connection?.Name.LocalName;
             }
 
             return string.Empty;
         }
 
         public string GetSerializationType()
         {
-            var serialisation = _xcApiDescription.GetSerializationNode()?.FirstOrDefault()?.Value;
-            return serialisation;
+            return _xcApiDescription.GetSerializationNode()?.FirstOrDefault()?.Value;
         }
 
         public BusDetails GetBusDetails()
         {
             XElement busInfos = _xcApiDescription.GetBusNode()?.FirstOrDefault();
             var busDetails = new BusDetails(
-                    busInfos?.Attribute("user")?.Value,
-                    busInfos?.Attribute("password")?.Value,
-                    busInfos?.Attribute("host")?.Value,
-                    Convert.ToInt32(busInfos?.Attribute("port")?.Value));
+                busInfos?.Attribute("user")?.Value,
+                busInfos?.Attribute("password")?.Value,
+                busInfos?.Attribute("host")?.Value,
+                Convert.ToInt32(busInfos?.Attribute("port")?.Value));
 
             return busDetails;
         }
@@ -186,32 +203,34 @@ public WebSocketEndpoint GetWebSocketEndpoint()
             }
 
             var webSocketEndpoint = new WebSocketEndpoint(
-                 websocketInfos?.Attribute("name")?.Value,
-                 websocketInfos?.Attribute("host")?.Value,
-                 websocketInfos?.Attribute("port")?.Value,
-                 webSocketType);
+                websocketInfos?.Attribute("name")?.Value,
+                websocketInfos?.Attribute("host")?.Value,
+                websocketInfos?.Attribute("port")?.Value,
+                webSocketType);
 
             return webSocketEndpoint;
         }
 
         public int GetComponentCode(string component)
         {
             int componentCode;
-            _componentCodeByComponent.TryGetValue(component, out componentCode);
+            _componentCodeByComponentNameRepository.TryGetValue(component, out componentCode);
             return componentCode;
         }
 
         public int GetStateMachineCode(string component, string stateMachine)
         {
-            int stateMachineCode = 0;
-            _stateMachineCodeByStateMachine?.TryGetValue(stateMachine, out stateMachineCode);
-            return stateMachineCode;
+            if (!_stateMachineInfoByComponentRepository.ContainsKey(component)) return 0;
+
+            var stateMachineInfo = _stateMachineInfoByComponentRepository[component]
+                ?.FirstOrDefault(stmInfo => stmInfo.StateMachineName.Equals(stateMachine));
+            return stateMachineInfo?.StateMachineCode ?? 0;
         }
 
         public int GetPublisherEventCode(string eventName)
         {
             int eventCode;
-            _eventCodeByEvent.TryGetValue(eventName, out eventCode);
+            _eventCodeByEventRepository.TryGetValue(eventName, out eventCode);
             return eventCode;
         }
 
@@ -222,17 +241,17 @@ public string GetPublisherTopic(string component, string stateMachine)
             var stateMachineCode = GetStateMachineCode(component, stateMachine);
             var topicId = new TopicIdentifier(componentCode, stateMachineCode, XCApiTags.Output);
 
-            _publisherTopicByIdentifier.TryGetValue(topicId, out publisherTopic);
+            _publisherTopicByIdentifierRepository.TryGetValue(topicId, out publisherTopic);
             return publisherTopic;
         }
 
         public string GetPublisherTopic(long componentCode, long stateMachineCode)
         {
             string publisherTopic;
-            var topicId = new TopicIdentifier(componentCode, stateMachineCode, XCApiTags.Output);
-
-            _publisherTopicByIdentifier.TryGetValue(topicId, out publisherTopic);
-
+            var topicId = new TopicIdentifier(componentCode, stateMachineCode, XCApiTags.Output);
+
+            _publisherTopicByIdentifierRepository.TryGetValue(topicId, out publisherTopic);
+
             return publisherTopic;
         }
 
@@ -243,16 +262,16 @@ public string GetSubscriberTopic(string component, string stateMachine)
             var stateMachineCode = GetStateMachineCode(component, stateMachine);
             var topicId = new TopicIdentifier(componentCode, stateMachineCode, XCApiTags.Input);
 
-            _subscriberTopicByIdentifier.TryGetValue(topicId, out subscriberTopic);
+            _subscriberTopicByIdentifierRepository.TryGetValue(topicId, out subscriberTopic);
             return subscriberTopic;
         }
 
         public string GetSnapshotTopic(string component)
         {
             string snapshotTopic;
             var componentCode = GetComponentCode(component);
-            _snapshotTopicByComponent.TryGetValue(componentCode, out snapshotTopic);
+            _snapshotTopicByComponentRepository.TryGetValue(componentCode, out snapshotTopic);
             return snapshotTopic;
         }
     }
-}
+}

ReactiveXComponent/ReactiveXComponent.csproj

@@ -98,6 +98,7 @@
     <Compile Include="Connection\IXCSubscriber.cs" />
     <Compile Include="Connection\IXCConnection.cs" />
     <Compile Include="Parser\IXCApiConfigParser.cs" />
+    <Compile Include="Parser\StateMachineInfo.cs" />
     <Compile Include="Parser\XCApiDescription.cs" />
     <Compile Include="Connection\IXCPublisher.cs" />
     <Compile Include="Connection\IXCSession.cs" />

Tools/packages.config tools/packages.configTools/packages.config renamed to tools/packages.config

@@ -2,4 +2,4 @@
 <packages>
     <package id="Cake" version="0.23.0" />
     <package id="XComponent.MSBuild.Tasks" version="1.0.0" />
-</packages>
+</packages>