1 files changed, 469 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller/customactiondata.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller/customactiondata.cs
new file mode 100644
index 00000000..88a0295d
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller/customactiondata.cs
@@ -0,0 +1,469 @@
+// 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.Dtf.WindowsInstaller
+{
+    using System;
+    using System.IO;
+    using System.Xml;
+    using System.Xml.Serialization;
+    using System.Text;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Contains a collection of key-value pairs suitable for passing between
+    /// immediate and deferred/rollback/commit custom actions.
+    /// </summary>
+    /// <remarks>
+    /// Call the <see cref="CustomActionData.ToString" /> method to get a string
+    /// suitable for storing in a property and reconstructing the custom action data later.
+    /// </remarks>
+    /// <seealso cref="Session.CustomActionData"/>
+    /// <seealso cref="Session.DoAction(string,CustomActionData)"/>
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
+    public sealed class CustomActionData : IDictionary<string, string>
+    {
+        /// <summary>
+        /// "CustomActionData" literal property name.
+        /// </summary>
+        public const string PropertyName = "CustomActionData";
+
+        private const char DataSeparator = ';';
+        private const char KeyValueSeparator = '=';
+
+        private IDictionary<string, string> data;
+
+        /// <summary>
+        /// Creates a new empty custom action data object.
+        /// </summary>
+        public CustomActionData() : this(null)
+        {
+        }
+
+        /// <summary>
+        /// Reconstructs a custom action data object from data that was previously
+        /// persisted in a string.
+        /// </summary>
+        /// <param name="keyValueList">Previous output from <see cref="CustomActionData.ToString" />.</param>
+        public CustomActionData(string keyValueList)
+        {
+            this.data = new Dictionary<string, string>();
+            
+            if (keyValueList != null)
+            {
+                this.Parse(keyValueList);
+            }
+        }
+
+        /// <summary>
+        /// Adds a key and value to the data collection.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <param name="value">Data value (may be null).</param>
+        /// <exception cref="ArgumentException">the key does not consist solely of letters,
+        /// numbers, and the period, underscore, and space characters.</exception>
+        public void Add(string key, string value)
+        {
+            CustomActionData.ValidateKey(key);
+            this.data.Add(key, value);
+        }
+
+        /// <summary>
+        /// Adds a value to the data collection, using XML serialization to persist the object as a string.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <param name="value">Data value (may be null).</param>
+        /// <exception cref="ArgumentException">the key does not consist solely of letters,
+        /// numbers, and the period, underscore, and space characters.</exception>
+        /// <exception cref="NotSupportedException">The value type does not support XML serialization.</exception>
+        /// <exception cref="InvalidOperationException">The value could not be serialized.</exception>
+        public void AddObject<T>(string key, T value)
+        {
+            if (value == null)
+            {
+                this.Add(key, null);
+            }
+            else if (typeof(T) == typeof(string) ||
+                     typeof(T) == typeof(CustomActionData)) // Serialize nested CustomActionData
+            {
+                this.Add(key, value.ToString());
+            }
+            else
+            {
+                string valueString = CustomActionData.Serialize<T>(value);
+                this.Add(key, valueString);
+            }
+        }
+
+        /// <summary>
+        /// Gets a value from the data collection, using XML serialization to load the object from a string.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <exception cref="InvalidOperationException">The value could not be deserialized.</exception>
+        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter")]
+        public T GetObject<T>(string key)
+        {
+            string value = this[key];
+            if (value == null)
+            {
+                return default(T);
+            }
+            else if (typeof(T) == typeof(string))
+            {
+                // Funny casting because the compiler doesn't know T is string here.
+                return (T) (object) value;
+            }
+            else if (typeof(T) == typeof(CustomActionData))
+            {
+                // Deserialize nested CustomActionData.
+                return (T) (object) new CustomActionData(value);
+            }
+            else if (value.Length == 0)
+            {
+                return default(T);
+            }
+            else
+            {
+                return CustomActionData.Deserialize<T>(value);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the data contains an item with the specified key.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <returns>true if the data contains an item with the key; otherwise, false</returns>
+        public bool ContainsKey(string key)
+        {
+            return this.data.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// Gets a collection object containing all the keys of the data.
+        /// </summary>
+        public ICollection<string> Keys
+        {
+            get
+            {
+                return this.data.Keys;
+            }
+        }
+
+        /// <summary>
+        /// Removes the item with the specified key from the data.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <returns>true if the item was successfully removed from the data;
+        /// false if an item with the specified key was not found</returns>
+        public bool Remove(string key)
+        {
+            return this.data.Remove(key);
+        }
+
+        /// <summary>
+        /// Gets the value with the specified key.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <param name="value">Value associated with the specified key, or
+        /// null if an item with the specified key was not found</param>
+        /// <returns>true if the data contains an item with the specified key; otherwise, false.</returns>
+        public bool TryGetValue(string key, out string value)
+        {
+            return this.data.TryGetValue(key, out value);
+        }
+
+        /// <summary>
+        /// Gets a collection containing all the values of the data.
+        /// </summary>
+        public ICollection<string> Values
+        {
+            get
+            {
+                return this.data.Values;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a data value with a specified key.
+        /// </summary>
+        /// <param name="key">Case-sensitive data key.</param>
+        /// <exception cref="ArgumentException">the key does not consist solely of letters,
+        /// numbers, and the period, underscore, and space characters.</exception>
+        public string this[string key]
+        {
+            get
+            {
+                return this.data[key];
+            }
+            set
+            {
+                CustomActionData.ValidateKey(key);
+                this.data[key] = value;
+            }
+        }
+
+        /// <summary>
+        /// Adds an item with key and value to the data collection.
+        /// </summary>
+        /// <param name="item">Case-sensitive data key, with a data value that may be null.</param>
+        /// <exception cref="ArgumentException">the key does not consist solely of letters,
+        /// numbers, and the period, underscore, and space characters.</exception>
+        public void Add(KeyValuePair<string, string> item)
+        {
+            CustomActionData.ValidateKey(item.Key);
+            this.data.Add(item);
+        }
+
+        /// <summary>
+        /// Removes all items from the data.
+        /// </summary>
+        public void Clear()
+        {
+            if (this.data.Count > 0)
+            {
+                this.data.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the data contains a specified item.
+        /// </summary>
+        /// <param name="item">The data item to locate.</param>
+        /// <returns>true if the data contains the item; otherwise, false</returns>
+        public bool Contains(KeyValuePair<string, string> item)
+        {
+            return this.data.Contains(item);
+        }
+
+        /// <summary>
+        /// Copies the data to an array, starting at a particular array index.
+        /// </summary>
+        /// <param name="array">Destination array.</param>
+        /// <param name="arrayIndex">Index in the array at which copying begins.</param>
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
+        {
+            this.data.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Gets the number of items in the data.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this.data.Count;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the data is read-only.
+        /// </summary>
+        public bool IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Removes an item from the data.
+        /// </summary>
+        /// <param name="item">The item to remove.</param>
+        /// <returns>true if the item was successfully removed from the data;
+        /// false if the item was not found</returns>
+        public bool Remove(KeyValuePair<string, string> item)
+        {
+            return this.data.Remove(item);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>An enumerator that can be used to iterate through the collection.</returns>
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            return this.data.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>An enumerator that can be used to iterate through the collection.</returns>
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return ((System.Collections.IEnumerable) this.data).GetEnumerator();
+        }
+
+        /// <summary>
+        /// Gets a string representation of the data suitable for persisting in a property.
+        /// </summary>
+        /// <returns>Data string in the form "Key1=Value1;Key2=Value2"</returns>
+        public override string ToString()
+        {
+            StringBuilder buf = new StringBuilder();
+
+            foreach (KeyValuePair<string, string> item in this.data)
+            {
+                if (buf.Length > 0)
+                {
+                    buf.Append(CustomActionData.DataSeparator);
+                }
+
+                buf.Append(item.Key);
+
+                if (item.Value != null)
+                {
+                    buf.Append(CustomActionData.KeyValueSeparator);
+                    buf.Append(CustomActionData.Escape(item.Value));
+                }
+            }
+
+            return buf.ToString();
+        }
+
+        /// <summary>
+        /// Ensures that a key contains valid characters.
+        /// </summary>
+        /// <param name="key">key to be validated</param>
+        /// <exception cref="ArgumentException">the key does not consist solely of letters,
+        /// numbers, and the period, underscore, and space characters.</exception>
+        private static void ValidateKey(string key)
+        {
+            if (String.IsNullOrEmpty(key))
+            {
+                throw new ArgumentNullException("key");
+            }
+
+            for (int i = 0; i < key.Length; i++)
+            {
+                char c = key[i];
+                if (!Char.IsLetterOrDigit(c) && c != '_' && c != '.' &&
+                    !(i > 0 && i < key.Length - 1 && c == ' '))
+                {
+                    throw new ArgumentOutOfRangeException("key");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Serializes a value into an XML string.
+        /// </summary>
+        /// <typeparam name="T">Type of the value.</typeparam>
+        /// <param name="value">Value to be serialized.</param>
+        /// <returns>Serialized value data as a string.</returns>
+        private static string Serialize<T>(T value)
+        {
+            XmlWriterSettings xws = new XmlWriterSettings();
+            xws.OmitXmlDeclaration = true;
+
+            StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
+            using (XmlWriter xw = XmlWriter.Create(sw, xws))
+            {
+                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
+                ns.Add(string.Empty, String.Empty); // Prevent output of any namespaces
+
+                XmlSerializer ser = new XmlSerializer(typeof(T));
+                ser.Serialize(xw, value, ns);
+
+                return sw.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Deserializes a value from an XML string.
+        /// </summary>
+        /// <typeparam name="T">Expected type of the value.</typeparam>
+        /// <param name="value">Serialized value data.</param>
+        /// <returns>Deserialized value object.</returns>
+        private static T Deserialize<T>(string value)
+        {
+            StringReader sr = new StringReader(value);
+            using (XmlReader xr = XmlReader.Create(sr))
+            {
+                XmlSerializer ser = new XmlSerializer(typeof(T));
+                return (T) ser.Deserialize(xr);
+            }
+        }
+
+        /// <summary>
+        /// Escapes a value string by doubling any data-separator (semicolon) characters.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>Escaped value string</returns>
+        private static string Escape(string value)
+        {
+            value = value.Replace(String.Empty + CustomActionData.DataSeparator, String.Empty + CustomActionData.DataSeparator + CustomActionData.DataSeparator);
+            return value;
+        }
+
+        /// <summary>
+        /// Unescapes a value string by undoubling any doubled data-separator (semicolon) characters.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>Unescaped value string</returns>
+        private static string Unescape(string value)
+        {
+            value = value.Replace(String.Empty + CustomActionData.DataSeparator + CustomActionData.DataSeparator, String.Empty + CustomActionData.DataSeparator);
+            return value;
+        }
+
+        /// <summary>
+        /// Loads key-value pairs from a string into the data collection.
+        /// </summary>
+        /// <param name="keyValueList">key-value pair list of the form returned by <see cref="ToString"/></param>
+        private void Parse(string keyValueList)
+        {
+            int itemStart = 0;
+            while (itemStart < keyValueList.Length)
+            {
+                // Find the next non-escaped data separator.
+                int semi = itemStart - 2;
+                do
+                {
+                    semi = keyValueList.IndexOf(CustomActionData.DataSeparator, semi + 2);
+                }
+                while (semi >= 0 && semi < keyValueList.Length - 1 && keyValueList[semi + 1] == CustomActionData.DataSeparator);
+
+                if (semi < 0)
+                {
+                    semi = keyValueList.Length;
+                }
+
+                // Find the next non-escaped key-value separator.
+                int equals = itemStart - 2;
+                do
+                {
+                    equals = keyValueList.IndexOf(CustomActionData.KeyValueSeparator, equals + 2);
+                }
+                while (equals >= 0 && equals < keyValueList.Length - 1 && keyValueList[equals + 1] == CustomActionData.KeyValueSeparator);
+
+                if (equals < 0 || equals > semi)
+                {
+                    equals = semi;
+                }
+
+                string key = keyValueList.Substring(itemStart, equals - itemStart);
+                string value = null;
+
+                // If there's a key-value separator before the next data separator, then the item has a value.
+                if (equals < semi)
+                {
+                    value = keyValueList.Substring(equals + 1, semi - (equals + 1));
+                    value = CustomActionData.Unescape(value);
+                }
+
+                // Add non-duplicate items to the collection.
+                if (key.Length > 0 && !this.data.ContainsKey(key))
+                {
+                    this.data.Add(key, value);
+                }
+
+                // Move past the data separator to the next item.
+                itemStart = semi + 1;
+            }
+        }
+    }
+}