//http://validationframework.codeplex.com/
//License:  Microsoft Permissive License (Ms-PL) v1.1  
using System;
using System.Xml;

namespace ValidationFramework.Extensions
{
    public static class XmlElementExtensions
    {
        /// <summary>
        /// weakly typed
        /// </summary>
        /// <param name="element"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        internal static object GetAttributeWithConversion(this XmlElement element, Type typeToConvertTo, string key)
        {
            if (!element.HasAttribute(key))
                throw new ArgumentOutOfRangeException(string.Format("The key &#039;{0}&#039; cannot be found in xml element.", key));

            var stringValue = element.GetAttribute(key);

            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeToConvertTo);

            return converter.ConvertFromString(stringValue);
        }
   }
}

   
     

   
 
#region License and Copyright
/*
 * Dotnet Commons Xml
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 */
#endregion

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.Serialization;

//using Dotnet.Commons.Reflection;

namespace Dotnet.Commons.Xml
{
  
  ///  
  /// <summary>
  /// This utility class contains wrapper functions that help to ease the handling and 
    /// manipulation of Xml documents, such as adding an element, adding an attribute
    /// to an element, copying and cloning of nodes, etc.
  ///
  /// </summary>
  /// 
    
  public abstract class XmlUtils
  {
        /// <summary>
        /// Remove all the xml namespaces (xmlns) attributes in the xml string
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>
        public static string RemoveAllXmlNamespace(string xmlData)
        {
            string xmlnsPattern = "s+xmlnss*(:w)?s*=s*"(?<url>[^"]*)"";
            MatchCollection matchCol = Regex.Matches(xmlData, xmlnsPattern);

            foreach (Match m in matchCol)
            {
                xmlData = xmlData.Replace(m.ToString(), "");
            }
            return xmlData;
        }
   }
}

   
     

   
 


//Microsoft Public License (Ms-PL)
//http://visualizer.codeplex.com/license

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;

namespace Redwerb.BizArk.Core.XmlExt
{
    /// <summary>
    /// Provides extension methods for processing Xml.
    /// </summary>
    public static class XmlExt
    {

        /// <summary>
        /// Gets a string from an attribute or node.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="name"></param>
        /// <param name="dfltVal"></param>
        /// <returns></returns>
        public static string GetString(this XmlNode node, string name, string dfltVal)
        {
            var att = node.Attributes[name];
            if (att != null) return att.Value;
            var child = node.SelectSingleNode(name);
            if (child != null) return child.InnerText;
            return dfltVal;
        }

    }

}

   
     

   
 


//http://validationframework.codeplex.com/
//License:  Microsoft Permissive License (Ms-PL) v1.1  
using System;
using System.Xml;

namespace ValidationFramework.Extensions
{
    public static class XmlElementExtensions
    {
        /// <summary>
        /// Attempts to get and convert an attribute from a <see cref="XmlElement"/>. If the item does not exist or can&#039;t be converted a <paramref name="defaultValue"/> is returned.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type"/> to try to convert to.</typeparam>
        /// <param name="element">The <see cref="XmlElement"/> to extract the attribute value from.</param>
        /// <param name="key">The key to use or the extraction</param>
        /// <param name="defaultValue">The default value if <paramref name="key"/> is not found.</param>
        /// <returns>The value from <paramref name="attributes"/> if <paramref name="key"/> exists; otherwise <paramref name="defaultValue"/>.</returns>
        internal static T GetAttribute<T>(this XmlElement element, string key, T defaultValue)
        {
            if (!element.HasAttribute(key))
                return defaultValue;

            var stringValue = element.GetAttribute(key);

            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));

            if (!converter.CanConvertFrom(typeof(string)))
                return defaultValue;

            return (T)converter.ConvertFromString(stringValue);
        }


    }
}

   
     

   
 
 
        
//http://validationframework.codeplex.com/
//License:  Microsoft Permissive License (Ms-PL) v1.1  
using System;
using System.Xml;

namespace ValidationFramework.Extensions
{
    public static class XmlElementExtensions
    {
        /// <summary>
        /// Attempts to get and cast attribute from a <see cref="XmlElement"/>. If the item does not exist or can&#039;t be casted exceptions are thrown.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type"/> to try to convert to.</typeparam>
        /// <param name="element">The <see cref="XmlElement"/> to extract the attribute value from.</param>
        /// <param name="key">The key to use or the extraction</param>
        /// <param name="defaultValue">The default value if <paramref name="key"/> is not found.</param>
        /// <returns>The value from <paramref name="attributes"/> if <paramref name="key"/> exists; otherwise <paramref name="defaultValue"/>.</returns>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        internal static T GetAttribute<T>(this XmlElement element, string key)
        {
            if (!element.HasAttribute(key))
                throw new ArgumentOutOfRangeException(string.Format("The key &#039;{0}&#039; cannot be found in xml element.", key));

            var stringValue = element.GetAttribute(key);

            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));

            return (T)converter.ConvertFromString(stringValue);
        }
   }
}

   
     

   
 
//Microsoft Public License (Ms-PL)
//http://dbmlmanager.codeplex.com/license

#region using
using System;
using System.Xml;
#endregion

namespace DbmlManager.Lib.Utility
{
  #region Class Docs
  /// <summary>
  /// Summary description for XmlUtil.
  /// </summary>
  #endregion

  public class XmlUtil
  {
    #region GetBoolAttrib(XmlNode node, string attrib, bool defVal)
    public static bool GetBoolAttrib(XmlNode node, string attrib, bool defVal)
    {
      XmlAttribute xmlAttrib = node.Attributes[attrib];
      if (xmlAttrib == null)
        return defVal;

      string val = xmlAttrib.Value;
      if (val == null || val == string.Empty)
        return defVal;

      bool returnVal = (val == "1" || val.ToLower() == "true");

      return returnVal;
    }
    #endregion
  }
}

   
     

   
 

#region License and Copyright
/*
 * Dotnet Commons Xml
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 */
#endregion

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.Serialization;

//using Dotnet.Commons.Reflection;

namespace Dotnet.Commons.Xml
{

    ///  
    /// <summary>
    /// This utility class contains wrapper functions that help to ease the handling and 
    /// manipulation of Xml documents, such as adding an element, adding an attribute
    /// to an element, copying and cloning of nodes, etc.
    ///
    /// </summary>
    /// 

    public abstract class XmlUtils
    {
        /// -------------------------------------------------------------------
        /// <summary>
        /// Adds an <see cref="XmlAttribute"/> to a <see cref="XmlNode"/>.
        /// </summary>
        /// <param name="node">Node in which an attribute is to be added</param>
        /// <param name="attributeName">attribute name</param>
        /// <param name="attributeValue">value of the attribute</param>
        /// <returns>true if successful, false otherwise</returns>
        /// -------------------------------------------------------------------
        public static void AddAttribute(XmlNode node,
                                        string attributeName,
                                        string attributeValue)
        {
            node.Attributes.Append(CreateAttribute(node,
                                                    attributeName,
                                                    attributeValue));
        }
        /// -----------------------------------------------------------
        /// <summary>
        /// Create an <see cref="XmlAttribute"/>.
        /// </summary>
        /// <param name="xmlDocument">XmlDocument object</param>
        /// <param name="attrName">name of the attribute</param>
        /// <param name="attrValue">value of the attribute</param>
        /// <returns>an instance of an XmlAttribute object</returns>
        /// -----------------------------------------------------------
        public static XmlAttribute CreateAttribute(XmlDocument xmlDocument,
                                                    string attrName,
                                                    string attrValue)
        {
            XmlAttribute oAtt = xmlDocument.CreateAttribute(attrName);
            oAtt.Value = attrValue;
            return oAtt;
        }

        /// -----------------------------------------------------------
        /// <summary>
        /// Create an <see cref="XmlAttribute"/> 
        /// </summary>
        /// <param name="node">Node to use for creating an attribute</param>    
        /// <param name="attrName">name of the attribute</param>
        /// <param name="attrValue">value of the attribute</param>
        /// <returns>an instance of an XmlAttribute object</returns>
        /// -----------------------------------------------------------
        public static XmlAttribute CreateAttribute(XmlNode node,
                                                    string attrName,
                                                    string attrValue)
        {
            return (CreateAttribute(node.OwnerDocument, attrName, attrValue));
        }
        /// -----------------------------------------------------------
        /// <summary>
        /// Adds an <see cref="XmlAttribute"/> to a <see cref="XmlNode"/>.
        /// </summary>
        /// <param name="node">Node in which an attribute is to be added</param>
        /// <param name="namespaceUri"></param>    
        /// <param name="attributeName">attribute name</param>
        /// <param name="attributeValue">value of the attribute</param>
        /// <returns>true if successful, false otherwise</returns>
        /// -----------------------------------------------------------
        public static void AddAttribute(XmlNode node,
                                        string namespaceUri,
                                        string attributeName,
                                        string attributeValue)
        {
            XmlAttribute attribute = node.OwnerDocument.CreateAttribute(attributeName, namespaceUri);
            attribute.Value = attributeValue;
            node.Attributes.Append(attribute);
        }
    }
}