XSL.cs

using System;
using System.Reflection;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Xsl;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Xsl
{
    public static class XSL
    {
        public static XmlSchema LoadSchema(string ResourceName)
        {
            return LoadSchema(ResourceName, Types.GetAssemblyForResource(ResourceName));
        }
 
        public static XmlSchema LoadSchema(string ResourceName, Assembly Assembly)
        {
            using (Stream f = Assembly.GetManifestResourceStream(ResourceName))
            {
                if (f is null)
                    throw new ArgumentException("Resource not found: " + ResourceName, nameof(ResourceName));
 
                return LoadSchema(f, ResourceName);
            }
        }
 
        public static XmlSchema LoadSchema(byte[] Input, string ResourceName)
        {
            using (MemoryStream ms = new MemoryStream(Input))
            {
                return LoadSchema(ms, ResourceName);
            }
        }
 
        public static XmlSchema LoadSchema(Stream Input, string ResourceName)
        {
            XmlValidator Validator = new XmlValidator(ResourceName);
            XmlSchema Result = XmlSchema.Read(Input, Validator.ValidationCallback);
 
            Validator.AssertNoError();
 
            return Result;
        }
 
        public static XslCompiledTransform LoadTransform(string ResourceName)
        {
            return LoadTransform(ResourceName, Types.GetAssemblyForResource(ResourceName));
        }
 
        public static XslCompiledTransform LoadTransform(string ResourceName, Assembly Assembly)
        {
            using (Stream f = Assembly.GetManifestResourceStream(ResourceName))
            {
                if (f is null)
                    throw new ArgumentException("Resource not found: " + ResourceName, nameof(ResourceName));
 
                return LoadTransform(f);
            }
        }
 
        public static XslCompiledTransform LoadTransform(Stream Input)
        {
            using (XmlReader r = XmlReader.Create(Input))
            {
                XslCompiledTransform Xslt = new XslCompiledTransform();
                Xslt.Load(r);
 
                return Xslt;
            }
        }
 
        #region Validation
 
        public static void Validate(string ObjectID, XmlDocument Xml, params XmlSchema[] Schemas)
        {
            Validate(ObjectID, Xml, string.Empty, string.Empty, Schemas);
        }
 
        public static void Validate(string ObjectID, XmlDocument Xml, string ExpectedRootElement, string ExpectedRootElementNamespace,
            params XmlSchema[] Schemas)
        {
            if (!string.IsNullOrEmpty(ExpectedRootElement))
            {
                if (Xml.DocumentElement is null)
                    throw new XmlSchemaException("Not root element.");
 
                if (Xml.DocumentElement.LocalName != ExpectedRootElement)
                {
                    throw new XmlSchemaException("Expected root element is " + ExpectedRootElement +
                        " but was " + Xml.DocumentElement.LocalName + ".");
                }
 
                if (Xml.DocumentElement.NamespaceURI != ExpectedRootElementNamespace)
                {
                    throw new XmlSchemaException("Expected root element namespace is " + ExpectedRootElementNamespace + 
                        " but was " + Xml.DocumentElement.NamespaceURI + ".");
                }
            }
 
            lock (xmlSchemaSetSynchronization)
            {
                foreach (XmlSchema Schema in Schemas)
                    Xml.Schemas.Add(Schema);
 
                XmlValidator Validator = new XmlValidator(ObjectID);
                Xml.Validate(Validator.ValidationCallback);
 
                Validator.AssertNoError();
            }
        }
 
        private static readonly object xmlSchemaSetSynchronization = new object();
 
        #endregion
 
        #region Transformation
 
        public static string Transform(string XML, XslCompiledTransform Transform)
        {
            StringBuilder Output = new StringBuilder();
            TextWriter OutputText = new StringWriter(Output);
            TextReader InputText = new StringReader(XML);
            XmlReader XmlReader = XmlReader.Create(InputText);
            XmlWriterSettings Settings = Content.Xml.XML.WriterSettings(false, true);
            Settings.ConformanceLevel = ConformanceLevel.Auto;
 
            XmlWriter XmlWriter = XmlWriter.Create(OutputText, Settings);
 
            try
            {
                Transform.Transform(XmlReader, XmlWriter);
            }
            finally
            {
                XmlWriter.Flush();
                OutputText.Flush();
 
                XmlReader.Close();
                InputText.Dispose();
 
                XmlWriter.Close();
                OutputText.Dispose();
            }
 
            return Output.ToString();
        }
 
        #endregion
 
    }
}