tool/cafex/Tools.cs

/*---------------------------------------------------------------------------*

  Copyright (C) Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

 *---------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;

namespace CafeX
{
    /// <summary>
    /// This class encapsulates the environment variables required by Cafe
    /// </summary>
    internal class EnvVar
    {
        private string var_name;
        private string var_value;
        private static Dictionary<string, EnvVar> dictionaryOfVariables = new Dictionary<string, EnvVar>();
        private static Dictionary<string, string> dictionaryOfSavedValues = new Dictionary<string, string>();

        public static void BackUpCurrentEnvironment()
        {
            #if DEBUG
                Log.WriteLine("BackUpCurrentEnvironment started.");
            #endif
            dictionaryOfSavedValues.Clear();

            foreach (string variableName in dictionaryOfVariables.Keys)
            {
                dictionaryOfSavedValues.Add(variableName, dictionaryOfVariables[variableName].value);
            }
            #if DEBUG
                Log.WriteLine("BackUpCurrentEnvironment completed.");
            #endif
        }

        public static void RestoreSavedEnvironment()
        {
            #if DEBUG
                Log.WriteLine("RestoreSavedEnvironment started.");
            #endif
            if (dictionaryOfSavedValues.Count == 0)
            {
                #if DEBUG
                    Log.WriteLine("RestoreSavedEnvironment ignored. No backup available.");
                #endif

                // No backup had been made, so there is no way to restore. Just return.
                return;
            }

            foreach (string variableName in dictionaryOfVariables.Keys)
            {
                // Set the respective envVar instance in the dictionary of variables.
                if (dictionaryOfSavedValues.ContainsKey(variableName))
                {
                    EnvVar temp = dictionaryOfVariables[variableName];
                    temp.value = dictionaryOfSavedValues[variableName];
                }
            }
            #if DEBUG
                Log.WriteLine("RestoreSavedEnvironment completed successfully.");
            #endif
        }

        public EnvVar(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name cannot be null.");
            }

            var_name = name;
            var_value = Environment.GetEnvironmentVariable(var_name);
            // Store the environment variable, so it can be backed-up and restored at will
            EnvVar.dictionaryOfVariables.Add(name, this);
        }

        public string value
        {
            get
            {
                var_value = Environment.GetEnvironmentVariable(var_name);
                return var_value;
            }

            set
            {
                var_value = value;
                Environment.SetEnvironmentVariable(var_name, var_value);
            }
        }

        public void AddToVar(string addition, char delimiter)
        {
            if (value == null)
                value = addition;
            else
                value = value + delimiter + addition;
        }

        public void RemoveFromVar(string removal, char delimiter)
        {
            if (string.IsNullOrEmpty(value))
            {
#if DEBUG
                Log.WriteLine("RemoveFromVar: removal is empty!");
#endif

                return;
            }
            if (string.IsNullOrEmpty(delimiter.ToString()))
            {
#if DEBUG
                Log.WriteLine("RemoveFromVar: delimiter is null!");
#endif

                return;
            }

            int position = value.IndexOf(removal);

            if (position >= 0)
            {
                int len = removal.Length;
                if (position > 0)
                {
                    // There is more text in value than only the one we want to remove.
                    // ex: data1 data2 removal data3
                    // ex: data1 removal.
                    // In those scenarios, we need to remove the delimiter char before, since AddToVar does value = value + delimiter + addition;
                    --position;
                    ++len;
                }

                value = value.Remove(position, len);
            }
            else
            {
#if DEBUG
                Log.WriteLine("RemoveFromVar: \"" + removal + "\" does not exist in the arg list!");
#endif
                return;
            }
        }


    }

    /// <summary>
    /// This class provides enables CafeX to work in both Windows and Cygwin environments by converting paths to the Windows format.
    /// </summary>
    internal static class PathConverter
    {
        /// <summary>
        /// Ensure the provide path is rooted.
        /// </summary>
        /// <param name="input">Path to a file.</param>
        /// <returns>Rooted path.</returns>
        internal static string Root(string input)
        {
            if (Path.IsPathRooted(input))
            {
                return input;
            }
            else
            {
                return Environment.CurrentDirectory + "\\" + input;
            }
        }

        /// <summary>
        /// Convert a Cygwin path to a Windows path.
        /// If the input is already a valid Windows path, it is returned unchanged.
        /// </summary>
        /// <param name="input">Cywin path.</param>
        /// <returns>Windows equivalent of the provided Cygwin path.</returns>
        internal static string Windowsify(string input)
        {
#if DEBUG
            Log.WriteLine("Windowsify input = " + input);
#endif
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}

            int cygdriverIndex = -1;

            cygdriverIndex = input.IndexOf(@"/cygdrive///");

            if ((cygdriverIndex == 0 || cygdriverIndex == 1 ) &&
                !string.IsNullOrEmpty(CafeX.Program.CYGWIN_PATH.value) )
            {
                // Special treatment
                input = input.Replace( @"/cygdrive///", Path.Combine(CafeX.Program.CYGWIN_PATH.value, "cygdrive/") );
                // it should continue with normal conversion to fix the \\
            }

            // Normal conversion -> path starts with /cygdriver/<stuff>  or "/cygdriver/<stuff>"
            cygdriverIndex = input.IndexOf("/cygdrive/");
            if (cygdriverIndex == 0 || cygdriverIndex == 1)
            {
                char drive_letter = input.ToCharArray()[10 + cygdriverIndex];
                input = input.Remove(0, 11 + cygdriverIndex);
                input = input.Replace('/', '\\');
                input = drive_letter + ":" + input;
            }
            else
            {
                // This should be a path that doesn't start with cygdrive,
                // so just make sure it has the proper \\ instead of /
                input = input.Replace('/', '\\');
            }

#if DEBUG
            Log.WriteLine("Windowsify return = " + input);
#endif
            return input;
        }
    }

    /// <summary>
    /// This class enables external processes to be started and monitored.
    /// </summary>
    internal static class ProcessExecutor
    {
        /// <summary>
        /// Creates a process, starts it, wait for its execution and return its exit code.
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable.</param>
        /// <returns>The process' exit code.</returns>
        internal static int DoProcess(string filename, string arguments)
        {
            #if DEBUG
                Log.WriteLine("ProcessorExecutor.DoProcess : " + filename + " " + arguments);
            #endif

            return DoProcess_WaitTime(filename, arguments, Int32.MaxValue);
        }

        /// <summary>
        /// Creates and starts a new process, but return immediately the execution to the caller.
        /// The child's stdout and errout is printed to this process' stdout.
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable.</param>
        /// <returns>0 if the process is created, -1 otherwise.</returns>
        internal static int DoProcess_DontWait(string filename, string arguments)
        {
            #if DEBUG
                Log.WriteLine("ProcessorExecutor.DoProcess_DontWait : " + filename + " " + arguments);
            #endif

            try
            {
                Process p = new Process();
                ProcessStartInfo si = new ProcessStartInfo(filename);
                si.UseShellExecute = false;
                si.CreateNoWindow = true;
                si.Arguments = arguments;
                si.RedirectStandardError = true;
                si.RedirectStandardOutput = true;
                p.StartInfo = si;
                // Won't wait, but need to connect stdout and stderr to this parent process.
                p.OutputDataReceived += (sender, args) => Console.WriteLine(args.Data);
                p.ErrorDataReceived += (sender, args) => Console.WriteLine(args.Data);
                p.Start();
                p.BeginOutputReadLine();
                p.BeginErrorReadLine();
                return 0;
            }
            catch (Exception e)
            {
                Console.WriteLine("CafeX Error: Exception in process executor");
                Console.WriteLine(filename + " " + arguments);
                Console.WriteLine(e.Message);
                return -1;
            }
        }

        /// <summary>
        /// Creates a process, starts it, and waits for a user-specified amount of time, then returns
        /// the process's exit code
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable</param>
        /// <param name="time">Time in milliseconds to wait.  Max 32-bit number implies forever.</param>
        /// <returns>The process' exit code</returns>
        internal static int DoProcess_WaitTime(string filename, string arguments, int time)
        {
#if DEBUG
            Log.WriteLine(String.Format("ProcessorExecutor.DoProcessWaitTime : {0} {1} {2}",filename,arguments,time));
#endif
            try
            {
                Process p = new Process();
                ProcessStartInfo si = new ProcessStartInfo(filename);
                si.UseShellExecute = false;
                si.CreateNoWindow = true;
                si.Arguments = arguments;
                si.RedirectStandardError = true;
                si.RedirectStandardOutput = true;
                p.StartInfo = si;

                p.Start();

                if (!p.WaitForExit(time))
                {
                    //Well this sucks.  Kill the process and hopefully the caller will try again
                    Log.WriteLine(String.Format("{0} didn't exit in time, so force kill it.", filename));
                    p.Kill();
                    p.WaitForExit(); // This had better work this time!
                }
                int ret = p.ExitCode;
                p.Close();
                p.Dispose();
                p = null;

                return ret;
            }
            catch (Exception e)
            {
                Console.WriteLine("CafeX Error: Exception in process executor");
                Console.WriteLine(filename + " " + arguments);
                Console.WriteLine(e.Message);
                return -1;
            }
        }

        /// <summary>
        /// Creates a process, starts it, wait for its execution and return its exit code.
        /// The child's process stdout is captured and returned to the caller in the ouput variable.
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable.</param>
        /// <param name="output">Returns the child's process captured output the the caller.</param>
        /// <returns>Chid's process exit code.</returns>
        internal static int DoProcess_GetOutput(string filename, string arguments, out string output)
        {
            #if DEBUG
                Log.WriteLine("ProcessorExecutor.DoProcess_GetOutput : " + filename + " " + arguments);
            #endif

            return DoProcess_GetOutput(filename, arguments, false, -1, out output);
        }

        /// <summary>
        /// Creates a process, starts it, wait for its execution and return its exit code.
        /// The child's process stdout is captured and returned to the caller in the ouput variable.
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable.</param>
        /// <param name="timeout">How long (in ms) to wait for the process to end. Set to values less than 1 to wait indefinately.</param>
        /// <param name="output">Returns the child's process captured output the the caller.</param>
        /// <returns>Chid's process exit code.</returns>
        internal static int DoProcess_GetOutput(string filename, string arguments, bool waitDataReceived, int timeout, out string output)
        {
            #if DEBUG
                Log.WriteLine("ProcessorExecutor.DoProcess_GetOutput : " + filename + " " + arguments);
            #endif

            try
            {
                int ret;
                bool isDataReceived = !(waitDataReceived); // If we want to wait for data received event (waitDataReceived=true), need to set isDataReceived = false.
                System.Threading.ManualResetEvent dataReceivedEvent = new System.Threading.ManualResetEvent(false);
                TimeSpan DATA_RECEIVE_FLUSH_TIMEOUT = new TimeSpan(0, 0, 2);
                Process p = new Process();
                ProcessStartInfo si = new ProcessStartInfo(filename);
                si.UseShellExecute = false;
                si.CreateNoWindow = true;
                si.Arguments = arguments;
                StringBuilder outputTmp = new StringBuilder();
                DataReceivedEventHandler callback = (sender, e) =>
                {
                    if (e != null && e.Data != null)
                    {
                        outputTmp.AppendLine( e.Data );
                        if (!isDataReceived)
                        {
                            isDataReceived = true;
                            dataReceivedEvent.Set();
                        }
                    }
                };

                si.RedirectStandardError = true;
                si.RedirectStandardOutput = true;
                p.StartInfo = si;
                p.OutputDataReceived += callback;
                p.ErrorDataReceived += callback;
                p.Start();
                p.BeginOutputReadLine();
                p.BeginErrorReadLine();
                bool exitedProperly = true;

                if (timeout > 0)
                {
                    exitedProperly = p.WaitForExit(timeout);
                    if (!exitedProperly)
                    {
                        Console.WriteLine("ERROR: Process started for '" + filename + " " + arguments + "' did not finish in the expected timeout (" + timeout.ToString() + "ms).");
                        Console.WriteLine("Dumping process std/out std/err until now:\n {0} \n", outputTmp.ToString());
                    }
                }
                else
                {
                    p.WaitForExit();
                }

                if (exitedProperly)
                {
                    ret = p.ExitCode;
                }
                else
                {
                    ret = -1;
                }

                // Some output should have been received either in stdout or stderr, so wait
                if (isDataReceived == false)
                {
                    dataReceivedEvent.WaitOne(DATA_RECEIVE_FLUSH_TIMEOUT);
                }

                p.CancelOutputRead();
                p.CancelErrorRead();
                p.StartInfo.RedirectStandardOutput = false;
                p.StartInfo.RedirectStandardError = false;
                p.OutputDataReceived -= callback;
                p.ErrorDataReceived -= callback;

                p.Close();
                p.Dispose();
                p = null;

                output = outputTmp.ToString();

                return ret;
            }
            catch (Exception e)
            {
                output = string.Empty;
                Console.WriteLine("CafeX Error: Exception in process executor");
                Console.WriteLine(filename + " " + arguments);
                Console.WriteLine(e.Message);
                return -1;
            }
        }

        /// <summary>
        /// Creates a process, starts it, wait for its execution and return its exit code.
        /// The child's process stdout and errout are set to a callback handler provided.
        /// </summary>
        /// <param name="filename">Path to the executable to start on a different process.</param>
        /// <param name="arguments">Arguments to the executable.</param>
        /// <param name="callback">An instance of DataReceivedEventHandler provided by the caller.</param>
        /// <returns>Chid's process exit code.</returns>
        internal static int StartProcess_RedirectOutput(string filename, string arguments, DataReceivedEventHandler callback, bool waitCompletion)
        {
            #if DEBUG
            Log.WriteLine("ProcessorExecutor.StartProcess_RedirectOutput : " + filename + " " + arguments);
            #endif

            try
            {
                Process p = new Process();
                ProcessStartInfo si = new ProcessStartInfo(filename);
                si.UseShellExecute = false;
                si.CreateNoWindow = true;
                si.Arguments = arguments;
                si.RedirectStandardError = true;
                si.RedirectStandardOutput = true;
                p.StartInfo = si;
                p.OutputDataReceived += callback;
                p.ErrorDataReceived += callback;

                p.Start();

                p.BeginOutputReadLine();
                p.BeginErrorReadLine();

                if (waitCompletion)
                {
                    p.WaitForExit();
                    int ret = p.ExitCode;
                    p.CancelOutputRead();
                    p.CancelErrorRead();
                    p.StartInfo.RedirectStandardOutput = false;
                    p.StartInfo.RedirectStandardError = false;
                    p.OutputDataReceived -= callback;
                    p.ErrorDataReceived -= callback;
                    p.Close();
                    p.Dispose();
                    p = null;

                    return ret;

                }
                else
                {
                    return 0;
                }

            }
            catch (Exception e)
            {
                Console.WriteLine("CafeX Error: Exception in process executor");
                Console.WriteLine(filename + " " + arguments);
                Console.WriteLine(e.Message);
                return -1;
            }
        }

        internal static int StartProcess_RedirectOutput(string filename, string arguments)
        {
#if DEBUG
            Log.WriteLine("ProcessorExecutor.StartProcess_RedirectOutput : " + filename + " " + arguments);
#endif

            try
            {
                Process p = new Process();
                ProcessStartInfo si = new ProcessStartInfo(filename);
                si.UseShellExecute = false;
                si.CreateNoWindow = true;
                si.Arguments = arguments;
                si.RedirectStandardError = true;
                si.RedirectStandardOutput = true;
                si.RedirectStandardInput = true;
                p.StartInfo = si;

                p.Start();

                p.BeginOutputReadLine();

                return 0;
            }
            catch (Exception e)
            {
                Console.WriteLine("CafeX Error: Exception in process executor");
                Console.WriteLine(filename + " " + arguments);
                Console.WriteLine(e.Message);
                return -1;
            }
        }
    }

    /// <summary>
    /// This class allows string arrays to be combined into a single string with the delimiter of choice.
    /// </summary>
    internal static class StringCombiner
    {
        internal static string MakeDelimitedString(string[] arr, char delimiter)
        {
            string ret = string.Empty;
            if (arr != null)
            {
                for (int i = 0; i < arr.Length; ++i)
                {
                    if (i == 0)
                    {
                        ret += arr[i];
                    }
                    else
                    {
                        ret += delimiter + arr[i];
                    }
                }
            }

            return ret;
        }
    }

    /// <summary>
    /// This class is used to edit xml content files.
    /// </summary>
    internal static class XmlHandler
    {
        /// <summary>
        /// Traverses the xml document from the provided root node until it finds the node that matches the provided name.
        /// </summary>
        /// <param name="root_name">Root node</param>
        /// <param name="node_name">Name of the node being searched</param>
        /// <returns>The node that matches the provided node name, null if it was not found.</returns>
        internal static XmlNode GetXmlNodeRecursive(XmlNode root_name, string node_name)
        {
            if (root_name.Name == node_name)
                return root_name;

            XmlNode ret = null;
            foreach (XmlNode child in root_name.ChildNodes)
            {
                ret = GetXmlNodeRecursive(child, node_name);
                if (ret != null)
                    break;
            }

            return ret;
        }

        /// <summary>
        /// Check if a node by the provided name exists inside an xml document.
        /// </summary>
        /// <param name="file_name">Full path to the xml document.</param>
        /// <param name="node_name">Name of the node to search.</param>
        /// <returns>True if the node was found, false otherwise.</returns>
        internal static bool NodeExists(string file_name, string node_name)
        {
#if DEBUG
            Log.WriteLine(string.Format("NodeExists: File: {0}, Node: {1}", file_name, node_name));
#endif
            XmlDocument document = new XmlDocument();
            document.Load(file_name);
            XmlNode node = GetXmlNodeRecursive(document.DocumentElement, node_name);
            return (node == null) ? false : true;
        }

        /// <summary>
        /// Returns the value of a node from an existing xml document.
        /// </summary>
        /// <param name="file_name">Full path to the xml document.</param>
        /// <param name="node_name">Name of the node to search.</param>
        /// <returns>String representing the node's value, null if the node was not found.</returns>
        internal static string GetNodeValue(string file_name, string node_name)
        {
            #if DEBUG
                Log.WriteLine("GetNodeValue called. file_name=" + file_name + ", node_name=" + node_name);
            #endif
            XmlDocument document = new XmlDocument();
            document.Load(file_name);
            XmlNode node = GetXmlNodeRecursive(document.DocumentElement, node_name);
            if (node == null)
            {
                Console.WriteLine("cafex xmlhandler getnodevalue failed: Node " + node_name + " does not exist in " + file_name);
                return null;
            }
            #if DEBUG
                Log.WriteLine("GetNodeValue return = " + node.InnerText);
            #endif
            return node.InnerText;
        }

        /// <summary>
        /// Updates the value of a node inside an xml document.
        /// </summary>
        /// <param name="file_name">Full path to the xml document.</param>
        /// <param name="node_name">Name of the node to search.</param>
        /// <param name="new_value">The new value for the node.</param>
        internal static void UpdateNodeValue(string file_name, string node_name, string new_value)
        {
            #if DEBUG
                Log.WriteLine("UpdateNodeValue called. file_name=" + file_name + ", node_name=" + node_name + ", new_value=" + new_value);
            #endif
            XmlDocument document = new XmlDocument();
            document.Load(file_name);
            XmlNode node = GetXmlNodeRecursive(document.DocumentElement, node_name);
            if (node == null)
            {
                Console.WriteLine("cafex xmlhandler updatenodevalue failed: Node " + node_name + " does not exist in " + file_name);
                return;
            }

            // Only update if necessary.
            if (node.InnerText != new_value)
            {
                if (File.Exists(file_name))
                {
                    // Strip the read-only attribute so we can overwrite it if it exists
                    File.SetAttributes(file_name, File.GetAttributes(file_name) & ~FileAttributes.ReadOnly);
                }

                // Before the update, check if the file is not locked for 3 times
                uint retries = Program.RETRY_ATTEMPS;
                while (FileUtil.IsFileLocked(file_name) && retries > 0)
                {
                    System.Threading.Thread.Sleep(Program.RETRY_TIMESPAN);
                    --retries;
                }

                node.InnerText = new_value;
                #if DEBUG
                    Log.WriteLine("updateNodeValue: file: " + file_name + ", node: " + node_name + ", newvalue: " + new_value);
                #endif
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.NewLineChars = "\n";
                settings.Indent = true;
                settings.Encoding = new UTF8Encoding(false);
                using (XmlWriter writer = XmlWriter.Create(file_name, settings))
                {
                    document.WriteTo(writer);
                    writer.Flush();
                    writer.Close();
                }

                File.SetAttributes(file_name, FileAttributes.Normal);
                #if DEBUG
                    Log.WriteLine("updateNodeValue completed on '" + file_name + "' and file in use = " + FileUtil.IsFileLocked(file_name));
                #endif
            }
        }

        /// <summary>
        /// Add an xml node to an xml document.
        /// </summary>
        /// <param name="file_name">Full path to the xml document.</param>
        /// <param name="node_name">Name for the new xml node.</param>
        /// <param name="value">Node's value.</param>
        /// <param name="attributes">Array of strings representing the node's attributes.</param>
        internal static void AddNode(string file_name, string node_name, string value, string[] attributes)
        {
#if DEBUG
            Log.WriteLine("AddNode called. file_name=" + file_name + ", node_name=" + node_name + ", value=" + value);
            string attrString = null;
            foreach (string attribute in attributes)
            {
                attrString += attribute + " ";
            }
            Log.WriteLine("Attributes = " + attrString);
#endif
            XmlDocument document = new XmlDocument();
            document.Load(file_name);
            XmlElement node = document.CreateElement(node_name);
            node.InnerText = value;

            for (int i = 0; i < attributes.Length; i += 2)
            {
                node.SetAttribute(attributes[i], attributes[i + 1]);
            }

            document.DocumentElement.AppendChild(node);
            #if DEBUG
                Log.WriteLine("AddNode: file: " + file_name + ", node: " + node_name + ", value: " + value);
            #endif
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.NewLineChars = "\n";
            settings.Indent = true;
            settings.Encoding = new UTF8Encoding(false);
            // Before the update, check if the file is not locked for 3 times
            uint retries = Program.RETRY_ATTEMPS;
            while (FileUtil.IsFileLocked(file_name) && retries > 0)
            {
                System.Threading.Thread.Sleep(Program.RETRY_TIMESPAN); // 1s
                --retries;
            }

            using (XmlWriter writer = XmlWriter.Create(file_name, settings))
            {
                document.WriteTo(writer);
                writer.Flush();
                writer.Close();
            }

            File.SetAttributes(file_name, FileAttributes.Normal);
            #if DEBUG
                Log.WriteLine("AddNode completed on '" + file_name + "' and file in use = " + FileUtil.IsFileLocked(file_name));
            #endif
        }

        /// <summary>
        /// Remove a node from an xml document.
        /// </summary>
        /// <param name="file_name">Full path to the xml document.</param>
        /// <param name="node_name">Name for the node to search.</param>
        internal static void RemoveNode(string file_name, string node_name)
        {
#if DEBUG
            Log.WriteLine("RemoveNode called. file_name=" + file_name + ", node_name=" + node_name);
#endif
            XmlDocument document = new XmlDocument();
            document.Load(file_name);
            XmlNode node = GetXmlNodeRecursive(document.DocumentElement, node_name);
            if (node == null)
            {
                return;
            }
            #if DEBUG
                Log.WriteLine("RemoveNode: file: " + file_name + ", node: " + node_name);
            #endif
            document.DocumentElement.RemoveChild(node);

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.NewLineChars = "\n";
            settings.Indent = true;
            settings.Encoding = new UTF8Encoding(false);
            // Before the update, check if the file is not locked for 3 times
            uint retries = Program.RETRY_ATTEMPS;
            while (FileUtil.IsFileLocked(file_name) && retries > 0)
            {
                System.Threading.Thread.Sleep(Program.RETRY_TIMESPAN); // 1s
                --retries;
            }

            using (XmlWriter writer = XmlWriter.Create(file_name, settings))
            {
                document.WriteTo(writer);
                writer.Flush();
                writer.Close();
            }

            File.SetAttributes(file_name, FileAttributes.Normal);
            #if DEBUG
                Log.WriteLine("RemoveNode completed on '" + file_name + "' and file in use = " + FileUtil.IsFileLocked(file_name));
            #endif
        }

        internal static void UpdateNodeValueByPath(string file_name, string xpath, string new_value)
        {
#if DEBUG
            Log.WriteLine("UpdateNodeValueByPath called.  file_name=" + file_name + ", xpath=" + xpath + ", new_value=" + new_value);
#endif

            XmlDocument document = new XmlDocument();
            document.Load(file_name);

            try
            {
                XmlNode target = document.SelectSingleNode(xpath);

                if (target == null)
                {
                    Console.WriteLine("cafex xmlhandler UpdateNodeValueByPath failed: Node specified by path " + xpath + " does not exist in " + file_name);
                    return;
                }

                if (target.InnerText != new_value)
                {
                    uint retries = Program.RETRY_ATTEMPS;
                    while (FileUtil.IsFileLocked(file_name) && retries > 0)
                    {
                        System.Threading.Thread.Sleep(Program.RETRY_TIMESPAN);
                        --retries;
                    }

                    target.InnerText = new_value;
#if DEBUG
                    Log.WriteLine("UpdateNodeValueByPath:  file=" + file_name + ", xpath=" + xpath + ", new_value=" + new_value);
#endif
                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.NewLineChars = "\n";
                    settings.Indent = true;
                    settings.Encoding = new UTF8Encoding(false);
                    using (XmlWriter writer = XmlWriter.Create(file_name, settings))
                    {
                        document.WriteTo(writer);
                        writer.Flush();
                        writer.Close();
                    }

                    File.SetAttributes(file_name, FileAttributes.Normal);
#if DEBUG
                    Log.WriteLine("UpdateNodeValueByPath completed on '" + file_name + "' and file in use = " + FileUtil.IsFileLocked(file_name));
#endif
                }
            }
            catch (System.Xml.XPath.XPathException)
            {
                Console.WriteLine("UpdateNodeValueByPath contained an invalid xpath parameter! xpath={0}\nNode will not be updated!",xpath);
                return;
            }
        }
    }

    /// <summary>
    /// Represents a title id hex string.
    /// </summary>
    internal class TitleId
    {
        private const int TitleIdLength = 16;
        private const int TitleIdHalfLength = TitleIdLength / 2;
        private static readonly string[] SystemTitleRanges = { "00050010", "0005001b", "00050030" };
        private const string HexPrefix = "0x";

        private string titleIdAsString;

        /// <summary>
        /// Creates new instance of TitleId, verifying that the input string is of the correct format.
        /// </summary>
        /// <param name="titleId">Title ID as string</param>
        /// <remarks>Throws <see cref="ArgumentException"/> on parsing failure.</remarks>
        public TitleId(string titleId)
        {
            ulong titleIdAsLong;

            if (titleId.StartsWith(HexPrefix))
            {
                titleId = titleId.Remove(0, HexPrefix.Length);
            }

            if (titleId.Length != TitleIdLength)
            {
                throw new ArgumentException("Title ID has incorrect length. A correct ID is 18 characters with the leading 0x, or 16 characters without 0x.");
            }

            if (!UInt64.TryParse(titleId, System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out titleIdAsLong))
            {
                throw new ArgumentException("Title ID has invalid characters. Only hexadecimal characters are allowed.");
            }

            this.titleIdAsString = titleId.StartsWith(HexPrefix) ? titleId.ToLowerInvariant() : string.Format("{0}{1}", HexPrefix, titleId).ToLowerInvariant();
        }

        /// <summary>
        /// Returns true if the input string is a valid title ID.
        /// </summary>
        /// <param name="input">Title ID as string</param>
        /// <returns>True if parsed, else false.</returns>
        public static bool TryParse(string input, out TitleId titleId)
        {
            try
            {
                titleId = new TitleId(input);
                return true;
            }
            catch (ArgumentException)
            {
                titleId = null;
                return false;
            }
        }

        /// <summary>
        /// Returns true if the high value of the title ID matches one of the system title high values.
        /// </summary>
        public bool IsSystemTitle
        {
            get
            {
                return SystemTitleRanges.Any(x => x == HighValue);
            }
        }

        /// <summary>
        /// Returns value of the title ID, with leading hex prefix.
        /// </summary>
        public string Value
        {
            get
            {
                return this.titleIdAsString;
            }
        }

        /// <summary>
        /// Returns value of the title ID, without the leading hex prefix.
        /// </summary>
        public string ValueWithoutPrefix
        {
            get
            {
                return this.titleIdAsString.Substring(HexPrefix.Length, TitleIdLength);
            }
        }

        /// <summary>
        /// High value (most significant bits) of the title ID.
        /// </summary>
        public string HighValue
        {
            get
            {
                return this.titleIdAsString.Substring(HexPrefix.Length, TitleIdHalfLength);
            }
        }

        /// <summary>
        /// Low value (least significant bits) of the title ID.
        /// </summary>
        public string LowValue
        {
            get
            {
                return this.titleIdAsString.Substring(HexPrefix.Length + TitleIdHalfLength, TitleIdHalfLength);
            }
        }
    }

    /// <summary>
    /// This class is a wrapper on HEX conversion functions used by CafeX.
    /// </summary>
    internal static class HexHandler
    {
        /// <summary>
        /// Transform the input string into its integer representation.
        /// Strings that are invalid representations of integers will cause exceptions.
        /// </summary>
        /// <param name="input">String representing a number.</param>
        /// <returns>The integer that represents the provided string.</returns>
        internal static uint GetNumberFromString(string input)
        {
#if DEBUG
            Log.WriteLine("GetNumberFromString called. input=" + input);
#endif
            if (input.StartsWith("0x"))
            {
                return Convert.ToUInt32(input, 16);
            }
            else
            {
                foreach (char c in input)
                {
                    if ((c >= 'a' || c >= 'A') &&
                        (c <= 'f' || c <= 'F'))
                    {
                        return Convert.ToUInt32(input, 16);
                    }
                }

                return Convert.ToUInt32(input);
            }
        }

        /// <summary>
        /// Transform the input string into its long representation.
        /// Strings that are invalid representations of longs will cause exceptions.
        /// </summary>
        /// <param name="input">String representing a number.</param>
        /// <returns>The long that represents the provided string.</returns>
        internal static long GetLongNumberFromString(string input)
        {
#if DEBUG
            Log.WriteLine("GetLongNumberFromString called. input=" + input);
#endif

            if (input.StartsWith("0x"))
            {
                return Convert.ToInt64(input, 16);
            }
            else
            {
                foreach (char c in input)
                {
                    if ((c >= 'a' || c >= 'A') &&
                        (c <= 'f' || c <= 'F'))
                    {
                        return Convert.ToInt64(input, 16);
                    }
                }
                return Convert.ToInt64(input);
            }
        }
    }

    /// <summary>
    /// Utilities for file verification.
    /// </summary>
    internal static class FileUtil
    {
        private static string cafex_system_wide_mtx_name = "Global\\cafex_system_wide_mtx";
        private static DateTime entryAssemblyTs;
        private static bool bRunningFromCygwin = false;
        private static string assemblyFileName;


        /// <summary>
        /// Initializes one-shot only utility variables
        /// </summary>
        internal static void GatherEnvironment()
        {
            string cygcheck;
            assemblyFileName = System.Reflection.Assembly.GetExecutingAssembly().Location;
            entryAssemblyTs = File.GetLastWriteTimeUtc(assemblyFileName);
            cygcheck = Environment.GetEnvironmentVariable("CYGCHECK");
            if ( !(string.IsNullOrEmpty(cygcheck)) )
            {
                if( cygcheck.StartsWith("cygwin" ) )
                {
                    bRunningFromCygwin = true;
                }
            }
        }


        /// <summary>
        /// Determine whether we are running from within cygwin
        /// </summary>
        internal static bool RunningFromCygwin
        {
            get { return bRunningFromCygwin; }
        }

        /// <summary>
        /// Check if a file is locked for R/W and/or delete.
        /// </summary>
        /// <param name="filename">Full path to the file.</param>
        /// <returns>True if the file is locked, false otherwise.</returns>
        internal static bool IsFileLocked(string filename)
        {
            FileStream stream = null;
            bool result = false;

            try
            {
                FileInfo file = new FileInfo(filename);
                stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
                result = false;
            }
            catch (IOException)
            {
                //the file is unavailable because it is:
                //a) still being written to
                //b) or being processed by another thread (maybe held by PCFS)
                //c) or does not exist (has already been processed)
#if DEBUG
                // Collect debug information to help troubleshoot who has this file handle
                try
                {
                    Process handleTool = new Process();
                    handleTool.StartInfo.FileName = "handle.exe";
                    handleTool.StartInfo.Arguments = filename + " /accepteula";
                    handleTool.StartInfo.UseShellExecute = false;
                    handleTool.StartInfo.RedirectStandardOutput = true;
                    handleTool.Start();
                    handleTool.WaitForExit();
                    string handleOutput = handleTool.StandardOutput.ReadToEnd();
                    Log.WriteLine("############## FILE LOCKED WARNING REPORT ##############");
                    Log.WriteLine("Filename = " + filename);
                    Log.WriteLine("Handles opened:");
                    Log.WriteLine(handleOutput);
                    Log.WriteLine("############## FILE LOCKED END OF REPORT  ##############");


                }
                catch (Exception)
                {
                    Log.WriteLine("Unable to get handle information on file " + filename);
                }
                finally
#endif
                {
                    result = true;
                }
            }
            finally
            {
                if (stream != null)
                {
                    stream.Close();
                }
            }

            return result;

        }


        /// <summary>
        /// Expand an executable to the temp folder from a resource location
        /// </summary>
        /// <param name="payload">Executable bytes from resource</param>
        /// <param name="filename">File to be written to disk</param>
        /// <returns>Full path to temporary file written to disk.</returns>
        internal static string ExpandExecutable(byte[] payload, string filename)
        {
            System.Threading.Mutex mtx = null;
            string full_tmp_path;

            full_tmp_path = Environment.GetEnvironmentVariable("CAFE_TEMP");

            if( string.IsNullOrEmpty(full_tmp_path) )
            {
                full_tmp_path = Environment.GetEnvironmentVariable("TEMP");
                if( string.IsNullOrEmpty(full_tmp_path)  )
                {
                    full_tmp_path = Environment.GetEnvironmentVariable("TMP");
                    if ( string.IsNullOrEmpty(full_tmp_path) )
                    {
                        full_tmp_path = Path.GetDirectoryName(assemblyFileName);
                    }
                }
            }


            full_tmp_path = PathConverter.Windowsify(full_tmp_path) + "\\" + filename;

            // the kinds of things that can prevent this from happening are all fatal
			// errors, don't try to catch anything
            mtx = new System.Threading.Mutex(false, cafex_system_wide_mtx_name);

            mtx.WaitOne();

            // from this point on, we must release the mutex no matter what happens!

            try
            {
                DateTime tempExeTs;
                bool doOverwrite = false;
                try
                {
                    tempExeTs = File.GetLastWriteTimeUtc(full_tmp_path);

                    // if the internal resource is newer than the file on disk
                    if (entryAssemblyTs >= tempExeTs)
                    {
                        doOverwrite = true;
                    }
                    // else, we will use the file that's there, as it is newer than we are
                }
                catch (FileNotFoundException)
                {
                    // file's not there - we will overwrite it
                    doOverwrite = true;
                }

                if (doOverwrite)
                {
					try
					{
                    	File.WriteAllBytes(full_tmp_path, payload);
					}
					catch( System.IO.DirectoryNotFoundException )
					{
						try
						{
							Directory.CreateDirectory( Path.GetDirectoryName(full_tmp_path) );
						}
						catch
						{
						}
						File.WriteAllBytes(full_tmp_path, payload);
					}

                }
            }
            finally
            {
                mtx.ReleaseMutex();
            }

            return full_tmp_path;

        }

        /// <summary>
        /// Check if the provide string is a valid file name.
        /// </summary>
        /// <param name="filename">String to check.</param>
        /// <returns>True if it is a valid file name, false otherwise.</returns>
        internal static bool IsValidFile(string filename, bool checkExistence)
        {
#if DEBUG
            Log.WriteLine("IsValidFile called. filename=" + filename + ", checkExistence=" + checkExistence.ToString());
#endif
            if (string.IsNullOrEmpty(filename))
            {
                return false;
            }

            // Convert to windows, if it was a cygwin path
            filename = PathConverter.Windowsify(filename);
            bool returnVal = false;
            try
            {
                FileInfo file = new FileInfo(filename);
                // A path without a filename resolves to a valid FileInfo instance
                // so we need to check if there is a file at the end of the path.
                if (Path.GetFileName(file.FullName).Length == 0)
                {
                    // There is no filename, only a valid path!
                    return false;
                }

                if (!checkExistence)
                {
                    returnVal = true;
                }
                else
                {
                    returnVal = file.Exists;
                }
            }
            catch (ArgumentException)
            {
            }
            catch (System.IO.PathTooLongException)
            {
            }
            catch (NotSupportedException)
            {
            }

#if DEBUG
            Log.WriteLine("IsValidFile return " + returnVal.ToString());
#endif
            return returnVal;
        }

        internal static void AddQuotes(ref string fileNameOrListWithSpaces)
        {
#if DEBUG
            Log.WriteLine("AddQuotes called. " + "fileNameOrListWithSpaces=" + fileNameOrListWithSpaces);
#endif
            if (string.IsNullOrEmpty(fileNameOrListWithSpaces))
            {
                return;
            }

            if (fileNameOrListWithSpaces.StartsWith("\"") && fileNameOrListWithSpaces.EndsWith("\""))
            {
                return;
            }

            fileNameOrListWithSpaces = "\"" + fileNameOrListWithSpaces + "\"";
        }


        /// <summary>
        /// Creates a directory if it does not already exist.
        /// </summary>
        /// <param name="directoryPath">Directory to create</param>
        internal static void DirectoryCreate(string directoryPath)
        {
#if DEBUG
            Console.WriteLine("FileUtil::DirectoryCreate: Creating '{0}' if it does not already exist", directoryPath);
#endif
            if (!Directory.Exists(directoryPath))
            {
                Directory.CreateDirectory(directoryPath);
            }
        }


        /// <summary>
        /// Copy a directory from one location to another with optional recursion.
        /// </summary>
        /// <param name="sourceDirName">Source folder name.</param>
        /// <param name="destDirName">Destination folder name.</param>
        /// <param name="copySubDirs">Flag to copy all of the sub-folders recurively.</param>
        internal static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs, bool overwriteFiles)
        {
#if DEBUG
            Console.WriteLine("FileUtil::DirectoryCopy: Copying '{0}' => '{1}'{2}", sourceDirName, destDirName, copySubDirs ? " recursively" : "");
#endif
            // Get the subdirectories for the specified directory.
            DirectoryInfo dir = new DirectoryInfo(sourceDirName);
            DirectoryInfo[] dirs = dir.GetDirectories();

            if (!dir.Exists)
            {
                throw new DirectoryNotFoundException("Source directory does not exist or could not be found: " + sourceDirName);
            }

            // If the destination directory doesn't exist, create it.
            if (!Directory.Exists(destDirName))
            {
                Directory.CreateDirectory(destDirName);
            }

            // Get the files in the directory and copy them to the new location.
            FileInfo[] files = dir.GetFiles();
            foreach (FileInfo file in files)
            {
                string temppath = Path.Combine(destDirName, file.Name);
                file.CopyTo(temppath, overwriteFiles);
            }

            // If copying subdirectories, copy them and their contents to new location.
            if (copySubDirs)
            {
                foreach (DirectoryInfo subdir in dirs)
                {
                    string temppath = Path.Combine(destDirName, subdir.Name);
                    DirectoryCopy(subdir.FullName, temppath, copySubDirs, overwriteFiles);
                }
            }
        }

        /// <summary>
        /// Deletes the content of a directory with optional recursion
        /// </summary>
        /// <param name="dirName">Directory folder name.</param>
        /// <param name="recursive">Flag to remove subdirectories recursively.</param>
        internal static void DirectoryDelete(string dirName, bool recursive)
        {
            if (Directory.Exists(dirName))
            {
#if DEBUG
                Console.WriteLine("FileUtil::DirectoryDelete: Deleting '{0}'{1}", dirName, recursive ? " recursively" : "");
#endif
                DirectoryInfo di = new DirectoryInfo(dirName);

                RemoveReadOnlyAttribute(di, recursive);

                // If the directory is a junction, this command will still work correctly.
                // That is, only the junction is deleted and not the contents of the linked directory.
                // Otherwise, the directory and its contents delete normally.
                di.Delete(recursive);
            }
        }

        internal static void RemoveReadOnlyAttribute(DirectoryInfo dirInfo, bool recursive)
        {
            // Change attributes of source directory
            if ((dirInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
            {
                dirInfo.Attributes = FileAttributes.Normal;
            }
            // Change all of the attributes in the directory specified by dirInfo
            foreach (FileInfo fi in dirInfo.GetFiles())
            {
                if ((fi.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                {
                    //don't modify any other flags.
                    fi.Attributes &= ~(FileAttributes.ReadOnly);
                }
            }
            // Recursively change attributes in all files in all directories if specified
            if (recursive)
            {
                //Can't use actual recursion because there would be a stack overflow.
                foreach (DirectoryInfo di in dirInfo.GetDirectories())
                {
                    // Change attributes of current directory
                    if ((di.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                    {
                        //don't modify any other flags.
                        di.Attributes &= ~(FileAttributes.ReadOnly);
                    }
                    // Change all of the attributes in the directory specified by dirInfo
                    foreach (FileInfo fi in di.GetFiles())
                    {
                        if ((fi.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                        {
                            //don't modify any other flags.
                            fi.Attributes &= ~(FileAttributes.ReadOnly);
                        }
                    }
                }
            }
        }

        internal static void FileDelete(string fileName)
        {
#if DEBUG
            Console.WriteLine("FileUtil::FileDelete: Deleting '{0}'", fileName);
#endif
            if (File.Exists(fileName))
            {
                // Strip any readonly, hidden and system attributes
                FileInfo fileInfo = new FileInfo(fileName);
                fileInfo.Attributes = FileAttributes.Normal;

                // Now delete the file
                File.Delete(fileName);
            }
        }

        /// <summary>
        /// Copies a file exactly (preserves timestamp). Creates target directory for file if needed.
        /// </summary>
        /// <param name="copyFromPath">Source file</param>
        /// <param name="copyToPath">Destination file</param>
        internal static void FileCopy(string copyFromPath, string copyToPath)
        {
#if DEBUG
            Console.WriteLine("FileUtil::FileCopy: Copying '{0}' to '{1}'", copyFromPath, copyToPath);
#endif
            // Strip read-only attriute if destination file already exists.
            if (File.Exists(copyToPath))
            {
                var target = new FileInfo(copyToPath);
                if (target.IsReadOnly)
                    target.IsReadOnly = false;
            }

            // Create destination dir if it doesn't already exist.
            string copyToDir = Path.GetDirectoryName(copyToPath);
            DirectoryCreate(copyToDir);

            // Now do the copy.
            var origin = new FileInfo(copyFromPath);
            origin.CopyTo(copyToPath, true);

            // And preserve its timestamp info and read-only attribute.
            var destination = new FileInfo(copyToPath);
            if (destination.IsReadOnly)
            {
                destination.IsReadOnly = false;
                destination.CreationTime = origin.CreationTime;
                destination.LastWriteTime = origin.LastWriteTime;
                destination.LastAccessTime = origin.LastAccessTime;
                destination.IsReadOnly = true;
            }
            else
            {
                destination.CreationTime = origin.CreationTime;
                destination.LastWriteTime = origin.LastWriteTime;
                destination.LastAccessTime = origin.LastAccessTime;
            }
        }
    }

    /// <summary>
    /// Log to the stdout and debug.  This is only used in debug builds.
    /// </summary>
    internal static class Log
    {
        internal static StreamWriter sw = null;

        internal static bool OpenLogFile(string logFilePath)
        {
            try
            {
                if (sw == null)
                {
                    string path = Environment.ExpandEnvironmentVariables(logFilePath);
                    path = PathConverter.Windowsify(path);
                    string directory = path.Substring(0, path.LastIndexOf('\\'));
                    if (!Directory.Exists(directory))
                    {
                        Directory.CreateDirectory(directory);
                    }
                    sw = new StreamWriter(path);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed to open the log file. InnerException: {0}", ex.Message);
                sw = null;
            }
            return (sw != null);
        }
        internal static void WriteLine(string message)
        {
            message = string.Format("[ {0} - DEBUG: {1} ] {2}", System.Diagnostics.Process.GetCurrentProcess().Id, DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-ffff"), message);
            Console.WriteLine(message);
            Debug.WriteLine(message);
            if (sw != null)
            {
                sw.WriteLine(message);
            }
        }

        internal static void WriteLine(string format, object arg0)
        {
            WriteLine(string.Format(format, arg0));
        }

        internal static void WriteLine(string format, object arg0, object arg1)
        {
            WriteLine(string.Format(format, arg0, arg1));
        }

        internal static void WriteLine(string format, object arg0, object arg1, object arg2)
        {
            WriteLine(string.Format(format, arg0, arg1, arg2));
        }

        internal static void WriteLineRaw(string message)
        {
            Console.WriteLine(message);
            Debug.WriteLine(message);
            if (sw != null)
            {
                sw.WriteLine(message);
            }
        }

        internal static void WriteLineRaw(string format, object arg0)
        {
            WriteLineRaw(string.Format(format, arg0));
        }

        internal static void WriteLineRaw(string format, object arg0, object arg1)
        {
            WriteLineRaw(string.Format(format, arg0, arg1));
        }

        internal static void WriteLineRaw(string format, object arg0, object arg1, object arg2)
        {
            WriteLineRaw(string.Format(format, arg0, arg1, arg2));
        }

        internal static void CloseLogFile()
        {
            if (sw != null)
            {
                sw.Close();
            }
        }
    }

    /// <summary>
    /// This class provides tools for argument validation.
    /// </summary>
    internal static class ArgumentChecks
    {
        internal static bool IsArgumentValidSetting(string[] args, int index)
        {
#if DEBUG
            Log.WriteLine("IsArgumentValidSetting called. Checking index=" + index.ToString());
            string argString = null;
            for (int counter = 0; counter < args.Length; ++counter)
            {
                argString += "{" + counter.ToString() + "}" + args[counter] + " ";
            }
            Log.WriteLine("arguments=" + argString);
#endif
            bool returnVal = false;
            // If the argument doesn't exist, it is not valid.
            if (!ArgumentExists(args, index))
            {
                returnVal = false;
            }
            else
            {
                // If the argument starts with '-' it is another option, not a setting.
                if (!args[index].StartsWith("-"))
                {
                    returnVal = true;
                }
                else
                {
                    returnVal = false;
                }
            }

#if DEBUG
            Log.WriteLine("IsArgumentValidSetting return " + returnVal.ToString());
#endif
            return returnVal;
        }

        /// <summary>
        /// Check if the provided index exists in the argument list.
        /// </summary>
        /// <param name="args">Array of string representing an argument list.</param>
        /// <param name="index">The index of the argument that will be checked.</param>
        /// <returns>True if the argument at the provide index exists, false otherwise.</returns>
        internal static bool ArgumentExists(string[] args, int index)
        {
            if (args == null || args.Length == 0 ||
                 index < 0 || index > (args.Length - 1))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    }

    internal class PerfTimer
    {
        private System.Diagnostics.Stopwatch _clock;
        private string _name;

        public string Name
        {
            get { return _name;}
        }

        public PerfTimer(string name)
        {
            _name = name;
            _clock = new Stopwatch();
        }

        public void Start()
        {
            Log.WriteLine("[TIMER]: Starting PerfTimer " + _name);
            _clock.Start();
        }

        public void Report()
        {
            Log.WriteLine("[TIMER]: PerfTimer " + _name + " current time is " + _clock.ElapsedMilliseconds + " ms.");
        }

        public void Stop()
        {
            _clock.Stop();
            Log.WriteLine("[TIMER]: PerfTimer " + _name + " stopped.");
            this.Report();
        }

        public void Reset()
        {
            _clock.Reset();
            Log.WriteLine("[TIMER]: PerfTimer " + _name + " reset.");
        }
    }
}