//******************************************************************************************************//  XmlExtensions.cs - Gbtc////  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  02/23/2003 - J. Ritchie Carroll//       Generated original version of source code.//  01/23/2006 - J. Ritchie Carroll//       Migrated 2.0 version of source code from 1.1 source (GSF.Shared.Common).//  01/24/2007 - J. Ritchie Carroll//       Added GetDataSet method to convert an XML string of data into a DataSet object.//  12/13/2007 - Darrell Zuercher//       Edited code comments.//  09/12/2008 - J. Ritchie Carroll//       Converted to C# extension functions.//  08/10/2009 - Josh L. Patterson//       Edited Comments.//  09/14/2009 - Stephen C. Wills//       Added new header and license agreement.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Data;using System.Diagnostics.CodeAnalysis;using System.IO;using System.Linq;using System.Xml;using System.Xml.Linq;using System.Xml.Xsl; namespace GSF.Xml{    /// <summary>    /// Defines extension functions related to Xml elements.    /// </summary>    public static class XmlExtensions    {        /// <summary>Gets an XML node from given path, creating the entire path if it does not exist.</summary>        /// <remarks>This overload just allows the start of the given XML document by using its root element.</remarks>        /// <param name="xmlDoc">An <see cref="XmlDocument"/> to query.</param>        /// <param name="xpath">A <see cref="string"/> xpath query.</param>        /// <returns>An <see cref="XmlNode"/> corresponding to the xpath query.</returns>        public static XmlNode GetXmlNode(this XmlDocument xmlDoc, string xpath) =>             xmlDoc.DocumentElement.GetXmlNode(xpath, out bool _);         /// <summary>Gets an XML node from given path, creating the entire path if it does not exist.</summary>        /// <remarks>        /// <para>This overload just allows the start of the given XML document by using its root element.</para>        /// <para>Note that the <paramref name="isDirty" /> parameter will be set to True if any items were added to        /// the tree.</para>        /// </remarks>        /// <param name="xmlDoc">An <see cref="XmlDocument"/> to query.</param>        /// <param name="xpath">A <see cref="string"/> xpath query.</param>        /// <param name="isDirty">A <see cref="System.Boolean"/> value indicating if items were added to the tree.</param>        /// <returns>An <see cref="XmlNode"/> corresponding to the xpath query.</returns>        public static XmlNode GetXmlNode(this XmlDocument xmlDoc, string xpath, out bool isDirty) =>             xmlDoc.DocumentElement.GetXmlNode(xpath, out isDirty);         /// <summary>Gets an XML node from given path, creating the entire path if it does not exist.</summary>        /// <param name="parentNode">An <see cref="XmlNode"/> parent node to query.</param>        /// <param name="xpath">A <see cref="string"/> xpath query.</param>        /// <returns>An <see cref="XmlNode"/> corresponding to the xpath query.</returns>        public static XmlNode GetXmlNode(this XmlNode parentNode, string xpath) =>             parentNode.GetXmlNode(xpath, out bool _);         /// <summary>Gets an XML node from given path, creating the entire path if it does not exist.</summary>        /// <remarks>Note that the <paramref name="isDirty" /> parameter will be set to True if any items were added to        /// the tree.</remarks>        /// <param name="parentNode">An <see cref="XmlNode"/> parent node to query.</param>        /// <param name="xpath">A <see cref="string"/> xpath query.</param>        /// <param name="isDirty">A <see cref="System.Boolean"/> value indicating if items were added to the tree.</param>        /// <returns>An <see cref="XmlNode"/> corresponding to the xpath query.</returns>        public static XmlNode GetXmlNode(this XmlNode parentNode, string xpath, out bool isDirty)        {            XmlNode node = null;             isDirty = false;             // Removes any slash prefixes.            while (xpath[0] == '/')                xpath = xpath.Substring(1);             string[] elements = xpath.Split('/');             if (elements.Length == 1)            {                XmlNodeList nodes = parentNode.SelectNodes(xpath);                 if (nodes is not null)                {                    if (nodes.Count == 0)                    {                        if (parentNode.OwnerDocument is not null)                        {                            node = parentNode.OwnerDocument.CreateElement(xpath);                            parentNode.AppendChild(node);                            isDirty = true;                        }                    }                    else                    {                        node = nodes[0];                    }                }            }            else            {                foreach (string element in elements)                {                    node = GetXmlNode(parentNode, element);                    parentNode = node;                }            }             return node;        }         /// <summary>Safely gets or sets an XML node's attribute.</summary>        /// <remarks>If you get an attribute that does not exist, null will be returned.</remarks>        /// <param name="name">A <see cref="string"/> name of the value to get.</param>        /// <param name="node">A <see cref="XmlNode"/> to query.</param>        /// <returns>A <see cref="string"/> value returned for the attribute's value.</returns>        public static string GetAttributeValue(this XmlNode node, string name)        {            if (node?.Attributes is null)                return null;             XmlAttribute attribute = node.Attributes[name];             return attribute?.Value;        }         /// <summary>Safely sets an XML node's attribute.</summary>        /// <remarks>If you assign a value to an attribute that does not exist, the attribute will be created.</remarks>        /// <param name="name">A <see cref="string"/> indicating the node name to use.</param>        /// <param name="node">An <see cref="XmlNode"/> node to operate on.</param>        /// <param name="value">A <see cref="string"/> value to set the node attribute's value to.</param>        public static void SetAttributeValue(this XmlNode node, string name, string value)        {            if (node?.Attributes is null)                return;             XmlAttribute attribute = node.Attributes[name];             if (attribute is null)            {                // Add the attribute.                if (node.OwnerDocument != null)                {                    attribute = node.OwnerDocument.CreateAttribute(name);                    attribute.Value = value;                    node.Attributes.Append(attribute);                }            }            else            {                // Set the attribute value.                attribute.Value = value;                node.Attributes.SetNamedItem(attribute);            }        }         /// <summary>        /// Gets a data set object from an XML data set formatted as a String.        /// </summary>        /// <param name="xmlData">XML data string in standard DataSet format.</param>        /// <returns>A <see cref="DataSet"/> object.</returns>        public static DataSet GetDataSet(this string xmlData)        {            DataSet dataSet = new DataSet();             using (XmlTextReader xmlReader = new XmlTextReader(xmlData, XmlNodeType.Document, null))            {                xmlReader.ReadOuterXml();                 // Reads the outer XML into the Dataset.                dataSet.ReadXml(xmlReader);            }             return dataSet;        }         /// <summary>        /// Transforms an XML document using the given XSL template.        /// </summary>        /// <param name="document">The document to be transformed.</param>        /// <param name="transform">The template that defines how the data should be transformed.</param>        /// <returns>The result of the transformation.</returns>        public static string ApplyXSLTransform(this string document, string transform)        {            using (StringReader documentReader = new StringReader(document))            using (StringReader transformReader = new StringReader(transform))            using (XmlReader xmlDocumentReader = XmlReader.Create(documentReader))            using (XmlReader xmlTransformReader = XmlReader.Create(transformReader))            using (StringWriter resultWriter = new StringWriter())            {                XslCompiledTransform compiler = new XslCompiledTransform();                compiler.Load(xmlTransformReader);                compiler.Transform(xmlDocumentReader, null, resultWriter);                return resultWriter.ToString();            }        }         /// <summary>        /// Transforms all elements in the given document matching the given        /// <paramref name="name"/> using the given <paramref name="selector"/>        /// function to perform the transformation.        /// </summary>        /// <param name="document">The document to be modified.</param>        /// <param name="name">The name of the elements to be transformed.</param>        /// <param name="selector">The function that defines the transformation.</param>        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This is a targeted extension for an XML document")]        public static void TransformAll(this XDocument document, XName name, Func<XElement, object> selector)        {            document                .Descendants(name)                .ToList()                .ForEach(element => element.ReplaceWith(selector(element)));        }         /// <summary>        /// Transforms all elements in the given document matching the given        /// <paramref name="name"/> using the given <paramref name="selector"/>        /// function to perform the transformation.        /// </summary>        /// <param name="document">The document to be modified.</param>        /// <param name="name">The name of the elements to be transformed.</param>        /// <param name="selector">The function that defines the transformation.</param>        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This is a targeted extension for an XML document")]        public static void TransformAll(this XDocument document, XName name, Func<XElement, int, object> selector)        {            document                .Descendants(name)                .Select((Element, Index) => new { Element, Index })                .ToList()                .ForEach(obj => obj.Element.ReplaceWith(selector(obj.Element, obj.Index)));        }         /// <summary>        /// Formats the contents of an XML element and returns the result.        /// </summary>        /// <param name="element">The elements whose contents are to be formatted.</param>        /// <returns>The formatted contents of the elements.</returns>        /// <remarks>        /// The format to be used is determined by the <c>type</c> and <c>spec</c>        /// attributes of the element. The <c>type</c> attribute should be the fully        /// qualified type name of an <see cref="IFormattable"/> type. The <c>spec</c>        /// attribute defines the format string to be used when formatting the contents.        /// If <c>type</c> or <c>spec</c> are not defined or if <c>type</c> resovles to        /// a type that is not <see cref="IFormattable"/>, the contents are not formatted        /// and are returned as-is.        /// </remarks>        public static object Format(this XElement element)        {            Type elementType = Type.GetType((string)element.Attribute("type"), false);            string formatString = (string)element.Attribute("spec");             if (elementType is null || formatString is null)                return element.Nodes();             if (!typeof(IFormattable).IsAssignableFrom(elementType))                return element.Nodes();             string value = (string)element;            IFormattable formattable = (IFormattable)Convert.ChangeType(value, elementType);            return new XText(formattable.ToString(formatString, null));        }         /// <summary>        /// Finds all attributes in an enumeration of <see cref="XElement"/> items that match the specified <paramref name="attributeName"/>.        /// </summary>        /// <param name="source">Set of <see cref="XElement"/> values to search.</param>        /// <param name="attributeName">Attribute name to match.</param>        /// <returns>Matching sets of <see cref="XElement"/> items and associated attribute values.</returns>        /// <remarks>        /// When used in conjunction with the <see cref="Is"/> extension, allows for expressions like:        /// <code>        /// var globals = XDocument.Load(configFile)        ///     .Descendants("SettingsGroup")        ///     .WhereAttribute("Type").Is("Globals");        /// </code>        /// </remarks>        public static IEnumerable<Tuple<XElement, string>> WhereAttribute(this IEnumerable<XElement> source, string attributeName) =>            source.Select(element => new Tuple<XElement, string>(element, element.Attribute(attributeName)?.Value))            .Where(tuple => !string.IsNullOrWhiteSpace(tuple.Item2));         /// <summary>        /// Finds all attributes queried from <see cref="WhereAttribute"/> that match <paramref name="attributeValue"/>.        /// </summary>        /// <param name="source">Attributes queried from <see cref="WhereAttribute"/> extension.</param>        /// <param name="attributeValue">Attribute value to match.</param>        /// <param name="ignoreCase">Flag that determines if attribute value match is case sensitive.</param>        /// <returns><see cref="XElement"/> items that match <paramref name="attributeValue"/>.</returns>        /// <remarks>        /// When used in conjunction with the <see cref="WhereAttribute"/> extension, allows for expressions like:        /// <code>        /// var globals = XDocument.Load(configFile)        ///     .Descendants("SettingsGroup")        ///     .WhereAttribute("Type").Is("Globals");        /// </code>        /// </remarks>        public static IEnumerable<XElement> Is(this IEnumerable<Tuple<XElement, string>> source, string attributeValue, bool ignoreCase = true) =>            source.Where(tuple => string.Equals(tuple.Item2, attributeValue, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))            .Select(tuple => tuple.Item1);    }}