public Build Read()

in src/StructuredLogger/Serialization/XmlLogReader.cs [35:145]
96 lines of code
25 McCabe index (conditional complexity)

        public Build Read(Stream stream)
        {
            Build build = new Build();
            this.stringTable = build.StringTable;

            var stack = new Stack<BaseNode>(1024);
            stack.Push(build);

            XmlNodeType previous = XmlNodeType.None;

            try
            {
                var xmlReaderSettings = new XmlReaderSettings()
                {
                    IgnoreWhitespace = true,
                };

                using (reader = XmlReader.Create(stream, xmlReaderSettings))
                {
                    reader.MoveToContent();

                    ReadAttributes();
                    PopulateAttributes(build); // read the attributes on the root Build element that we created manually

                    while (reader.Read())
                    {
                        var nodeType = reader.NodeType;
                        switch (reader.NodeType)
                        {
                            case XmlNodeType.Element:
                                var node = ReadNode();

                                var parent = (TreeNode)stack.Peek();
                                parent.AddChild(node);

                                if (!reader.IsEmptyElement)
                                {
                                    stack.Push(node);
                                }

                                break;
                            case XmlNodeType.EndElement:
                                {
                                    // if the element content is an empty string
                                    if (previous == XmlNodeType.Element)
                                    {
                                        var valueNode = stack.Peek();
                                        SetElementValue(valueNode, "");
                                    }

                                    stack.Pop();
                                    break;
                                }
                            case XmlNodeType.Text:
                                {
                                    var valueNode = stack.Peek();
                                    string value = reader.Value;
                                    SetElementValue(valueNode, stringTable.Intern(value));

                                    break;
                                }
                            case XmlNodeType.Whitespace:
                                {
                                    var valueNode = stack.Peek();
                                    var nameValueNode = valueNode as NameValueNode;
                                    if (nameValueNode != null)
                                    {
                                        nameValueNode.Value = GetCurrentValue();
                                    }
                                    else
                                    {
                                        var message = valueNode as Message;
                                        if (message != null)
                                        {
                                            message.Text = GetCurrentValue();
                                        }
                                    }

                                    break;
                                }
                            case XmlNodeType.None:
                            case XmlNodeType.Attribute:
                            case XmlNodeType.CDATA:
                            case XmlNodeType.EntityReference:
                            case XmlNodeType.Entity:
                            case XmlNodeType.ProcessingInstruction:
                            case XmlNodeType.Comment:
                            case XmlNodeType.Document:
                            case XmlNodeType.DocumentType:
                            case XmlNodeType.DocumentFragment:
                            case XmlNodeType.Notation:
                            case XmlNodeType.SignificantWhitespace:
                            case XmlNodeType.EndEntity:
                            case XmlNodeType.XmlDeclaration:
                            default:
                                break;
                        }

                        previous = nodeType;
                    }
                }
            }
            catch (Exception ex)
            {
                build = new Build() { Succeeded = false };
                build.AddChild(new Error() { Text = "Error when opening XML log file." });
                build.AddChild(new Error() { Text = ex.ToString() });
            }

            return build;
        }