XmlLiteral.cs

using System;
using System.Collections;
using System.Text;
using System.Xml;
using Waher.Content.Xml;
using Waher.Runtime.Inventory;
 
namespace Waher.Content.Semantic.Model.Literals
{
    public class XmlLiteral : SemanticLiteral
    {
        private readonly string encapsulatingNamespace;
        private readonly string language = null;
        private string normalizedXml = null;
 
        public XmlLiteral()
            : base()
        {
        }
 
        public XmlLiteral(IEnumerable Value, string EncapsulatingNamespace, string Language)
            : base(Value, ToString(Value))
        {
            this.encapsulatingNamespace = EncapsulatingNamespace;
            this.language = Language;
        }
 
        private static string ToString(IEnumerable List)
        {
            StringBuilder sb = new StringBuilder();
 
            foreach (XmlNode N in List)
                sb.Append(N.OuterXml);
 
            return sb.ToString();
        }
 
        public XmlLiteral(XmlNodeList Value, string EncapsulatingNamespace, string StringValue, string Language)
            : base(Value, StringValue)
        {
            this.encapsulatingNamespace = EncapsulatingNamespace;
            this.language = Language;
        }
 
        public const string TypeUri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral";
 
        public override string StringType => TypeUri;
 
        public override Grade Supports(Type ValueType)
        {
            return Grade.NotAtAll;
        }
 
        public override ISemanticLiteral Encapsulate(object Value)
        {
            return new StringLiteral(Value?.ToString() ?? string.Empty);
        }
 
        public override ISemanticLiteral Parse(string Value, string DataType, string Language)
        {
            try
            {
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
 
                Doc.LoadXml(Value);
 
                return new XmlLiteral(Doc.ChildNodes, string.Empty, Value, Language);
            }
            catch (Exception)
            {
                return new CustomLiteral(Value, DataType, Language);
            }
        }
 
        public string NormalizedXml
        {
            get
            {
                if (this.normalizedXml is null)
                {
                    XmlNormalizationState State = new XmlNormalizationState();
                    XML.NormalizeXml((XmlNodeList)this.Value, false, this.encapsulatingNamespace, State);
                    this.normalizedXml = State.ToString();
                }
 
                return this.normalizedXml;
            }
        }
 
        public override bool Equals(object obj)
        {
            string s2;
 
            if (obj is XmlLiteral Typed)
            {
                if (this.language != Typed.language)
                    return false;
 
                s2 = Typed.NormalizedXml;
            }
            else if (obj is CustomLiteral Custom && Custom.StringType == TypeUri)
            {
                if (this.language != Custom.Language)
                    return false;
 
                try
                {
                    XmlDocument Doc = new XmlDocument()
                    {
                        PreserveWhitespace = true
                    };
                    Doc.LoadXml("<root>" + Custom.StringValue + "</root>");
 
                    s2 = XML.NormalizeXml(Doc.DocumentElement.ChildNodes, false);
                }
                catch (Exception)
                {
                    return false;
                }
            }
            else
                return false;
 
            string s1 = this.NormalizedXml;
 
            return s1 == s2;
        }
 
        public override int GetHashCode()
        {
            int Result = this.NormalizedXml.GetHashCode();
            Result ^= Result << 5 ^ (this.language?.GetHashCode() ?? 0);
            return Result;
        }
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append('"');
            sb.Append(JSON.Encode(this.StringValue));
            sb.Append('"');
 
            if (!string.IsNullOrEmpty(this.language))
            {
                sb.Append('@');
                sb.Append(this.language);
            }
 
            sb.Append("^^<");
            sb.Append(this.StringType);
            sb.Append('>');
 
            return sb.ToString();
        }
 
    }
}