Merge Dtf

1 files changed, 297 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller/ColumnInfo.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller/ColumnInfo.cs
new file mode 100644
index 00000000..43363230
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller/ColumnInfo.cs
@@ -0,0 +1,297 @@
+// 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.Text;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Defines a single column of a table in an installer database.
+    /// </summary>
+    /// <remarks>Once created, a ColumnInfo object is immutable.</remarks>
+    public class ColumnInfo
+    {
+        private string name;
+        private Type type;
+        private int size;
+        private bool isRequired;
+        private bool isTemporary;
+        private bool isLocalizable;
+
+        /// <summary>
+        /// Creates a new ColumnInfo object from a column definition.
+        /// </summary>
+        /// <param name="name">name of the column</param>
+        /// <param name="columnDefinition">column definition string</param>
+        /// <seealso cref="ColumnDefinitionString"/>
+        public ColumnInfo(string name, string columnDefinition)
+            : this(name, typeof(String), 0, false, false, false)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            if (columnDefinition == null)
+            {
+                throw new ArgumentNullException("columnDefinition");
+            }
+
+            switch (Char.ToLower(columnDefinition[0], CultureInfo.InvariantCulture))
+            {
+                case 'i': this.type = typeof(Int32);
+                    break;
+                case 'j': this.type = typeof(Int32); this.isTemporary = true;
+                    break;
+                case 'g': this.type = typeof(String); this.isTemporary = true;
+                    break;
+                case 'l': this.type = typeof(String); this.isLocalizable = true;
+                    break;
+                case 'o': this.type = typeof(Stream); this.isTemporary = true;
+                    break;
+                case 's': this.type = typeof(String);
+                    break;
+                case 'v': this.type = typeof(Stream);
+                    break;
+                default: throw new InstallerException();
+            }
+
+            this.isRequired = Char.IsLower(columnDefinition[0]);
+            this.size = Int32.Parse(
+                columnDefinition.Substring(1),
+                CultureInfo.InvariantCulture.NumberFormat);
+            if (this.type == typeof(Int32) && this.size <= 2)
+            {
+                this.type = typeof(Int16);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new ColumnInfo object from a list of parameters.
+        /// </summary>
+        /// <param name="name">name of the column</param>
+        /// <param name="type">type of the column; must be one of the following:
+        /// Int16, Int32, String, or Stream</param>
+        /// <param name="size">the maximum number of characters for String columns;
+        /// ignored for other column types</param>
+        /// <param name="isRequired">true if the column is required to have a non-null value</param>
+        public ColumnInfo(string name, Type type, int size, bool isRequired)
+            : this(name, type, size, isRequired, false, false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new ColumnInfo object from a list of parameters.
+        /// </summary>
+        /// <param name="name">name of the column</param>
+        /// <param name="type">type of the column; must be one of the following:
+        /// Int16, Int32, String, or Stream</param>
+        /// <param name="size">the maximum number of characters for String columns;
+        /// ignored for other column types</param>
+        /// <param name="isRequired">true if the column is required to have a non-null value</param>
+        /// <param name="isTemporary">true to if the column is only in-memory and
+        /// not persisted with the database</param>
+        /// <param name="isLocalizable">for String columns, indicates the column
+        /// is localizable; ignored for other column types</param>
+        public ColumnInfo(string name, Type type, int size, bool isRequired, bool isTemporary, bool isLocalizable)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            if (type == typeof(Int32))
+            {
+                size = 4;
+                isLocalizable = false;
+            }
+            else if (type == typeof(Int16))
+            {
+                size = 2;
+                isLocalizable = false;
+            }
+            else if (type == typeof(String))
+            {
+            }
+            else if (type == typeof(Stream))
+            {
+                isLocalizable = false;
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException("type");
+            }
+
+            this.name = name;
+            this.type = type;
+            this.size = size;
+            this.isRequired = isRequired;
+            this.isTemporary = isTemporary;
+            this.isLocalizable = isLocalizable;
+        }
+
+        /// <summary>
+        /// Gets the name of the column.
+        /// </summary>
+        /// <value>name of the column</value>
+        public string Name
+        {
+            get { return this.name; }
+        }
+
+        /// <summary>
+        /// Gets the type of the column as a System.Type.  This is one of the following: Int16, Int32, String, or Stream
+        /// </summary>
+        /// <value>type of the column</value>
+        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods")]
+        public Type Type
+        {
+            get { return this.type; }
+        }
+
+        /// <summary>
+        /// Gets the type of the column as an integer that can be cast to a System.Data.DbType.  This is one of the following: Int16, Int32, String, or Binary
+        /// </summary>
+        /// <value>equivalent DbType of the column as an integer</value>
+        public int DBType
+        {
+            get
+            {
+                if (this.type == typeof(Int16)) return 10;
+                else if (this.type == typeof(Int32)) return 11;
+                else if (this.type == typeof(Stream)) return 1;
+                else return 16;
+            }
+        }
+
+        /// <summary>
+        /// Gets the size of the column.
+        /// </summary>
+        /// <value>The size of integer columns this is either 2 or 4.  For string columns this is the maximum
+        /// recommended length of the string, or 0 for unlimited length.  For stream columns, 0 is returned.</value>
+        public int Size
+        {
+            get { return this.size; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the column must be non-null when inserting a record.
+        /// </summary>
+        /// <value>required status of the column</value>
+        public bool IsRequired
+        {
+            get { return this.isRequired; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the column is temporary. Temporary columns are not persisted
+        /// when the database is saved to disk.
+        /// </summary>
+        /// <value>temporary status of the column</value>
+        public bool IsTemporary
+        {
+            get { return this.isTemporary; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the column is a string column that is localizable.
+        /// </summary>
+        /// <value>localizable status of the column</value>
+        public bool IsLocalizable
+        {
+            get { return this.isLocalizable; }
+        }
+
+        /// <summary>
+        /// Gets an SQL fragment that can be used to create this column within a CREATE TABLE statement.
+        /// </summary>
+        /// <value>SQL fragment to be used for creating the column</value>
+        /// <remarks><p>
+        /// Examples:
+        /// <list type="bullet">
+        /// <item>LONG</item>
+        /// <item>SHORT TEMPORARY</item>
+        /// <item>CHAR(0) LOCALIZABLE</item>
+        /// <item>CHAR(72) NOT NULL LOCALIZABLE</item>
+        /// <item>OBJECT</item>
+        /// </list>
+        /// </p></remarks>
+        public string SqlCreateString
+        {
+            get
+            {
+                StringBuilder s = new StringBuilder();
+                s.AppendFormat("`{0}` ", this.name);
+                if (this.type == typeof(Int16)) s.Append("SHORT");
+                else if (this.type == typeof(Int32)) s.Append("LONG");
+                else if (this.type == typeof(String)) s.AppendFormat("CHAR({0})", this.size);
+                else s.Append("OBJECT");
+                if (this.isRequired) s.Append(" NOT NULL");
+                if (this.isTemporary) s.Append(" TEMPORARY");
+                if (this.isLocalizable) s.Append(" LOCALIZABLE");
+                return s.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Gets a short string defining the type and size of the column. 
+        /// </summary>
+        /// <value>
+        /// The definition string consists
+        /// of a single letter representing the data type followed by the width of the column (in characters
+        /// when applicable, bytes otherwise). A width of zero designates an unbounded width (for example,
+        /// long text fields and streams). An uppercase letter indicates that null values are allowed in
+        /// the column.
+        /// </value>
+        /// <remarks><p>
+        /// <list>
+        /// <item>s? - String, variable length (?=1-255)</item>
+        /// <item>s0 - String, variable length</item>
+        /// <item>i2 - Short integer</item>
+        /// <item>i4 - Long integer</item>
+        /// <item>v0 - Binary Stream</item>
+        /// <item>g? - Temporary string (?=0-255)</item>
+        /// <item>j? - Temporary integer (?=0,1,2,4)</item>
+        /// <item>O0 - Temporary object (stream)</item>
+        /// <item>l? - Localizable string, variable length (?=1-255)</item>
+        /// <item>l0 - Localizable string, variable length</item>
+        /// </list>
+        /// </p></remarks>
+        public string ColumnDefinitionString
+        {
+            get
+            {
+                char t;
+                if (this.type == typeof(Int16) || this.type == typeof(Int32))
+                {
+                    t = (this.isTemporary ? 'j' : 'i');
+                }
+                else if (this.type == typeof(String))
+                {
+                    t = (this.isTemporary ? 'g' : this.isLocalizable ? 'l' : 's');
+                }
+                else
+                {
+                    t = (this.isTemporary ? 'O' : 'v');
+                }
+                return String.Format(
+                    CultureInfo.InvariantCulture,
+                    "{0}{1}",
+                    (this.isRequired ? t : Char.ToUpper(t, CultureInfo.InvariantCulture)),
+                    this.size);
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the column.
+        /// </summary>
+        /// <returns>Name of the column.</returns>
+        public override string ToString()
+        {
+            return this.Name;
+        }
+    }
+}