1 files changed, 302 insertions, 0 deletions

diff --git a/src/WixToolset.Core.Burn/RowIndexedList.cs b/src/WixToolset.Core.Burn/RowIndexedList.cs
new file mode 100644
index 00000000..3a4dad38
--- /dev/null
+++ b/src/WixToolset.Core.Burn/RowIndexedList.cs
@@ -0,0 +1,302 @@
+// 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.Core.Burn
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Data.WindowsInstaller;
+
+    /// <summary>
+    /// A list of rows indexed by their primary key. Unlike a <see cref="RowDictionary"/>
+    /// this indexed list will track rows in their added order and will allow rows with
+    /// duplicate keys to be added to the list, although only the first row will be indexed.
+    /// </summary>
+    public sealed class RowIndexedList<T> : IList<T> where T : Row
+    {
+        private Dictionary<string, T> index;
+        private List<T> rows;
+        private List<T> duplicates;
+
+        /// <summary>
+        /// Creates an empty <see cref="RowIndexedList"/>.
+        /// </summary>
+        public RowIndexedList()
+        {
+            this.index = new Dictionary<string, T>(StringComparer.InvariantCulture);
+            this.rows = new List<T>();
+            this.duplicates = new List<T>();
+        }
+
+        /// <summary>
+        /// Creates and populates a <see cref="RowDictionary"/> with the rows from the given enumerator.
+        /// </summary>
+        /// <param name="rows">Rows to index.</param>
+        public RowIndexedList(IEnumerable<T> rows)
+            : this()
+        {
+            foreach (T row in rows)
+            {
+                this.Add(row);
+            }
+        }
+
+        /// <summary>
+        /// Creates and populates a <see cref="RowDictionary"/> with the rows from the given <see cref="Table"/>.
+        /// </summary>
+        /// <param name="table">The table to index.</param>
+        /// <remarks>
+        /// Rows added to the index are not automatically added to the given <paramref name="table"/>.
+        /// </remarks>
+        public RowIndexedList(Table table)
+            : this()
+        {
+            if (null != table)
+            {
+                foreach (T row in table.Rows)
+                {
+                    this.Add(row);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the duplicates in the list.
+        /// </summary>
+        public IEnumerable<T> Duplicates { get { return this.duplicates; } }
+
+        /// <summary>
+        /// Gets the row by integer key.
+        /// </summary>
+        /// <param name="key">Integer key to look up.</param>
+        /// <returns>Row or null if key is not found.</returns>
+        public T Get(int key)
+        {
+            return this.Get(key.ToString());
+        }
+
+        /// <summary>
+        /// Gets the row by string key.
+        /// </summary>
+        /// <param name="key">String key to look up.</param>
+        /// <returns>Row or null if key is not found.</returns>
+        public T Get(string key)
+        {
+            T result;
+            return this.TryGet(key, out result) ? result : null;
+        }
+
+        /// <summary>
+        /// Gets the row by string key if it exists.
+        /// </summary>
+        /// <param name="key">Key of row to get.</param>
+        /// <param name="row">Row found.</param>
+        /// <returns>True if key was found otherwise false.</returns>
+        public bool TryGet(string key, out T row)
+        {
+            return this.index.TryGetValue(key, out row);
+        }
+
+        /// <summary>
+        /// Tries to add a row as long as it would not create a duplicate.
+        /// </summary>
+        /// <param name="row">Row to add.</param>
+        /// <returns>True if the row as added otherwise false.</returns>
+        public bool TryAdd(T row)
+        {
+            try
+            {
+                this.index.Add(row.GetKey(), row);
+            }
+            catch (ArgumentException) // if the key already exists, bail.
+            {
+                return false;
+            }
+
+            this.rows.Add(row);
+            return true;
+        }
+
+        /// <summary>
+        /// Adds a row to the list. If a row with the same key is already index, the row is
+        /// is not in the index but will still be part of the list and added to the duplicates
+        /// list.
+        /// </summary>
+        /// <param name="row"></param>
+        public void Add(T row)
+        {
+            this.rows.Add(row);
+            try
+            {
+                this.index.Add(row.GetKey(), row);
+            }
+            catch (ArgumentException) // if the key already exists, we have a duplicate.
+            {
+                this.duplicates.Add(row);
+            }
+        }
+
+        /// <summary>
+        /// Gets the index of a row.
+        /// </summary>
+        /// <param name="row">Iterates through the list of rows to find the index of a particular row.</param>
+        /// <returns>Index of row or -1 if not found.</returns>
+        public int IndexOf(T row)
+        {
+            return this.rows.IndexOf(row);
+        }
+
+        /// <summary>
+        /// Inserts a row at a particular index of the list.
+        /// </summary>
+        /// <param name="index">Index to insert the row after.</param>
+        /// <param name="row">Row to insert.</param>
+        public void Insert(int index, T row)
+        {
+            this.rows.Insert(index, row);
+            try
+            {
+                this.index.Add(row.GetKey(), row);
+            }
+            catch (ArgumentException) // if the key already exists, we have a duplicate.
+            {
+                this.duplicates.Add(row);
+            }
+        }
+
+        /// <summary>
+        /// Removes a row from a particular index.
+        /// </summary>
+        /// <param name="index">Index to remove the row at.</param>
+        public void RemoveAt(int index)
+        {
+            T row = this.rows[index];
+
+            this.rows.RemoveAt(index);
+
+            T indexRow;
+            if (this.index.TryGetValue(row.GetKey(), out indexRow) && indexRow == row)
+            {
+                this.index.Remove(row.GetKey());
+            }
+            else // only try to remove from duplicates if the row was not indexed (if it was indexed, it wasn't a dupe).
+            {
+                this.duplicates.Remove(row);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a row at the specified index.
+        /// </summary>
+        /// <param name="index">Index to get the row.</param>
+        /// <returns>Row at specified index.</returns>
+        public T this[int index]
+        {
+            get
+            {
+                return this.rows[index];
+            }
+            set
+            {
+                this.rows[index] = value;
+                try
+                {
+                    this.index.Add(value.GetKey(), value);
+                }
+                catch (ArgumentException) // if the key already exists, we have a duplicate.
+                {
+                    this.duplicates.Add(value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Empties the list and it's index.
+        /// </summary>
+        public void Clear()
+        {
+            this.index.Clear();
+            this.rows.Clear();
+            this.duplicates.Clear();
+        }
+
+        /// <summary>
+        /// Searches the list for a row without using the index.
+        /// </summary>
+        /// <param name="row">Row to look for in the list.</param>
+        /// <returns>True if the row is in the list, otherwise false.</returns>
+        public bool Contains(T row)
+        {
+            return this.rows.Contains(row);
+        }
+
+        /// <summary>
+        /// Copies the rows of the list to an array.
+        /// </summary>
+        /// <param name="array">Array to copy the list into.</param>
+        /// <param name="arrayIndex">Index to start copying at.</param>
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            this.rows.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Number of rows in the list.
+        /// </summary>
+        public int Count
+        {
+            get { return this.rows.Count; }
+        }
+
+        /// <summary>
+        /// Indicates whether the list is read-only. Always false.
+        /// </summary>
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Removes a row from the list. Indexed rows will be removed but the colleciton will NOT
+        /// promote duplicates to the index automatically. The duplicate would also need to be removed
+        /// and re-added to be indexed.
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        public bool Remove(T row)
+        {
+            bool removed = this.rows.Remove(row);
+            if (removed)
+            {
+                T indexRow;
+                if (this.index.TryGetValue(row.GetKey(), out indexRow) && indexRow == row)
+                {
+                    this.index.Remove(row.GetKey());
+                }
+                else // only try to remove from duplicates if the row was not indexed (if it was indexed, it wasn't a dupe).
+                {
+                    this.duplicates.Remove(row);
+                }
+            }
+
+            return removed;
+        }
+
+        /// <summary>
+        /// Gets an enumerator over the whole list.
+        /// </summary>
+        /// <returns>List enumerator.</returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            return this.rows.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Gets an untyped enumerator over the whole list.
+        /// </summary>
+        /// <returns>Untyped list enumerator.</returns>
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.rows.GetEnumerator();
+        }
+    }
+}