Move to .NET Core 2.0

1 files changed, 240 insertions, 0 deletions

diff --git a/src/WixToolset.Data/Section.cs b/src/WixToolset.Data/Section.cs
new file mode 100644
index 00000000..6757aa77
--- /dev/null
+++ b/src/WixToolset.Data/Section.cs
@@ -0,0 +1,240 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Data
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Linq;
+    using System.Xml;
+
+    /// <summary>
+    /// Section in an object file.
+    /// </summary>
+    public sealed class Section
+    {
+        /// <summary>
+        /// Creates a new section as part of an intermediate.
+        /// </summary>
+        /// <param name="id">Identifier for section.</param>
+        /// <param name="type">Type of section.</param>
+        /// <param name="codepage">Codepage for resulting database.</param>
+        public Section(string id, SectionType type, int codepage)
+        {
+            this.Id = id;
+            this.Type = type;
+            this.Codepage = codepage;
+
+            this.Tables = new TableIndexedCollection();
+        }
+
+        /// <summary>
+        /// Gets the identifier for the section.
+        /// </summary>
+        /// <value>Section identifier.</value>
+        public string Id { get; private set; }
+
+        /// <summary>
+        /// Gets the type of the section.
+        /// </summary>
+        /// <value>Type of section.</value>
+        public SectionType Type { get; private set; }
+
+        /// <summary>
+        /// Gets the codepage for the section.
+        /// </summary>
+        /// <value>Codepage for the section.</value>
+        public int Codepage { get; private set; }
+
+        /// <summary>
+        /// Gets the tables in the section.
+        /// </summary>
+        /// <value>Tables in section.</value>
+        public TableIndexedCollection Tables { get; private set; }
+
+        /// <summary>
+        /// Gets the source line information of the file containing this section.
+        /// </summary>
+        /// <value>The source line information of the file containing this section.</value>
+        public SourceLineNumber SourceLineNumbers { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the intermediate the section is contained within.
+        /// </summary>
+        public string IntermediateId { get; internal set; }
+
+        /// <summary>
+        /// Gets the identity of the library when the section is contained within one.
+        /// </summary>
+        public string LibraryId { get; internal set; }
+
+        /// <summary>
+        /// Ensures a table is added to the section's table collection.
+        /// </summary>
+        /// <param name="tableDefinition">Table definition for the table.</param>
+        /// <returns>Table in the section.</returns>
+        public Table EnsureTable(TableDefinition tableDefinition)
+        {
+            Table table;
+            if (!this.Tables.TryGetTable(tableDefinition.Name, out table))
+            {
+                table = new Table(this, tableDefinition);
+                this.Tables.Add(table);
+            }
+
+            return table;
+        }
+
+        /// <summary>
+        /// Parse a section from the xml.
+        /// </summary>
+        /// <param name="reader">XmlReader where the intermediate is persisted.</param>
+        /// <param name="tableDefinitions">TableDefinitions to use in the intermediate.</param>
+        /// <returns>The parsed Section.</returns>
+        internal static Section Read(XmlReader reader, TableDefinitionCollection tableDefinitions)
+        {
+            Debug.Assert("section" == reader.LocalName);
+
+            int codepage = 0;
+            bool empty = reader.IsEmptyElement;
+            string id = null;
+            SectionType type = SectionType.Unknown;
+
+            while (reader.MoveToNextAttribute())
+            {
+                switch (reader.Name)
+                {
+                    case "codepage":
+                        codepage = Convert.ToInt32(reader.Value, CultureInfo.InvariantCulture);
+                        break;
+                    case "id":
+                        id = reader.Value;
+                        break;
+                    case "type":
+                        switch (reader.Value)
+                        {
+                            case "bundle":
+                                type = SectionType.Bundle;
+                                break;
+                            case "fragment":
+                                type = SectionType.Fragment;
+                                break;
+                            case "module":
+                                type = SectionType.Module;
+                                break;
+                            case "patchCreation":
+                                type = SectionType.PatchCreation;
+                                break;
+                            case "product":
+                                type = SectionType.Product;
+                                break;
+                            case "patch":
+                                type = SectionType.Patch;
+                                break;
+                            default:
+                                throw new XmlException();
+                        }
+                        break;
+                }
+            }
+
+            if (null == id && (SectionType.Unknown != type && SectionType.Fragment != type))
+            {
+                throw new XmlException();
+            }
+
+            if (SectionType.Unknown == type)
+            {
+                throw new XmlException();
+            }
+
+            Section section = new Section(id, type, codepage);
+            section.SourceLineNumbers = SourceLineNumber.CreateFromUri(reader.BaseURI);
+
+            List<Table> tables = new List<Table>();
+            if (!empty)
+            {
+                bool done = false;
+
+                while (!done && reader.Read())
+                {
+                    switch (reader.NodeType)
+                    {
+                        case XmlNodeType.Element:
+                            switch (reader.LocalName)
+                            {
+                                case "table":
+                                    tables.Add(Table.Read(reader, section, tableDefinitions));
+                                    break;
+                                default:
+                                    throw new XmlException();
+                            }
+                            break;
+                        case XmlNodeType.EndElement:
+                            done = true;
+                            break;
+                    }
+                }
+
+                if (!done)
+                {
+                    throw new XmlException();
+                }
+            }
+
+            section.Tables = new TableIndexedCollection(tables);
+
+            return section;
+        }
+
+        /// <summary>
+        /// Persist the Section to an XmlWriter.
+        /// </summary>
+        /// <param name="writer">XmlWriter which reference will be persisted to.</param>
+        internal void Write(XmlWriter writer)
+        {
+            writer.WriteStartElement("section", Intermediate.XmlNamespaceUri);
+
+            if (null != this.Id)
+            {
+                writer.WriteAttributeString("id", this.Id);
+            }
+
+            switch (this.Type)
+            {
+                case SectionType.Bundle:
+                    writer.WriteAttributeString("type", "bundle");
+                    break;
+                case SectionType.Fragment:
+                    writer.WriteAttributeString("type", "fragment");
+                    break;
+                case SectionType.Module:
+                    writer.WriteAttributeString("type", "module");
+                    break;
+                case SectionType.Product:
+                    writer.WriteAttributeString("type", "product");
+                    break;
+                case SectionType.PatchCreation:
+                    writer.WriteAttributeString("type", "patchCreation");
+                    break;
+                case SectionType.Patch:
+                    writer.WriteAttributeString("type", "patch");
+                    break;
+            }
+
+            if (0 != this.Codepage)
+            {
+                writer.WriteAttributeString("codepage", this.Codepage.ToString());
+            }
+
+            // save the rows in table order
+            foreach (Table table in this.Tables.OrderBy(t => t.Name))
+            {
+                table.Write(writer);
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+}