XML Support

Author: gruenwaldlk

.idea/.idea.PetroglyphTools/.idea/projectSettingsUpdater.xml

@@ -17,4 +17,4 @@ public interface IId : IEquatable<IId>
     /// </summary>
     /// <returns></returns>
     string Unwrap();
-}
+}

PG.Commons/PG.Commons/Data/IId.cs

@@ -43,6 +43,12 @@ public string Unwrap()
         return b.ToString();
     }
 
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return Unwrap();
+    }
+
     /// <summary>
     ///     Convenience method to access components in a type-safe manner.
     /// </summary>
@@ -65,7 +71,10 @@ public string Unwrap()
     /// <inheritdoc />
     public override int GetHashCode()
     {
-        return HashCode.Combine(GetConfiguredArity(), HashCode.Combine(Components));
+        var hash = Arity.GetHashCode();
+        hash = Components.OfType<object>()
+            .Aggregate(hash, (current, component) => current * 31 + component.GetHashCode());
+        return hash;
     }
 
     /// <summary>
@@ -74,12 +83,12 @@ public override int GetHashCode()
     /// <returns></returns>
     protected virtual bool IsNullId()
     {
-        return Components.Any();
+        return Components.Any(o => o != null);
     }
 
     /// <summary>
     ///     The arity of this ID type.
     /// </summary>
     /// <returns></returns>
     protected abstract int GetConfiguredArity();
-}
+}

PG.Commons/PG.Commons/Data/IdBase.cs

@@ -0,0 +1,40 @@
+namespace PG.Commons.Data.Serialization;
+
+/// <summary>
+///     Simple XML serialization helper service.
+/// </summary>
+public interface IXmlSerializationSupportService
+{
+    /// <summary>
+    ///     Serializes an object to XML and stores it to the file path.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="serializableObject"></param>
+    /// <param name="overwrite"></param>
+    /// <typeparam name="T"></typeparam>
+    bool SerializeObjectAndStoreToDisc<T>(string filePath, T serializableObject, bool overwrite = true) where T : class;
+
+    /// <summary>
+    ///     Serializes the given object to an XML string.
+    /// </summary>
+    /// <param name="serializableObject"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    string SerializeObject<T>(T serializableObject) where T : class;
+
+    /// <summary>
+    ///     Deserializes an XML file read form disc to an object.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    T? DeSerializeObjectFromDisc<T>(string filePath) where T : class;
+
+    /// <summary>
+    ///     Deserializes an object from a XML string.
+    /// </summary>
+    /// <param name="xmlString"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    T? DeSerializeObject<T>(string xmlString) where T : class;
+}

PG.Commons/PG.Commons/Data/Serialization/IXmlSerializationSupportService.cs

@@ -0,0 +1,84 @@
+// Copyright (c) Alamo Engine Tools and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+using Microsoft.Extensions.Logging;
+using PG.Commons.Services;
+
+namespace PG.Commons.Data.Serialization;
+
+/// <inheritdoc cref="IXmlSerializationSupportService" />
+public sealed class XmlSerializationSupportService : ServiceBase, IXmlSerializationSupportService
+{
+    /// <inheritdoc />
+    public XmlSerializationSupportService(IServiceProvider services) : base(services)
+    {
+    }
+
+    /// <inheritdoc />
+    public string SerializeObject<T>(T serializableObject) where T : class
+    {
+        try
+        {
+            var xmlSerializer = new XmlSerializer(typeof(T));
+            var stringWriter = new StringWriter();
+            using var writer = XmlWriter.Create(stringWriter);
+            xmlSerializer.Serialize(writer, serializableObject);
+            return stringWriter.ToString();
+        }
+        catch (Exception e)
+        {
+            Logger.LogError("An exception occurred whilst serializing: {}", e);
+        }
+
+        return string.Empty;
+    }
+
+    /// <inheritdoc />
+    public T? DeSerializeObjectFromDisc<T>(string filePath) where T : class
+    {
+        var fileInfo = FileSystem.FileInfo.New(filePath);
+        if (!fileInfo.Exists) throw new FileNotFoundException("The file {} could not be found!", filePath);
+        return DeSerializeObject<T>(FileSystem.File.ReadAllText(filePath));
+    }
+
+    /// <inheritdoc />
+    public T? DeSerializeObject<T>(string xmlString) where T : class
+    {
+        if (string.IsNullOrEmpty(xmlString)) return null;
+        var xmlSerializer = new XmlSerializer(typeof(T));
+        var stringReader = new StringReader(xmlString);
+        using var reader = XmlReader.Create(stringReader);
+        var obj = xmlSerializer.Deserialize(reader);
+        return obj as T;
+    }
+
+    /// <inheritdoc />
+    public bool SerializeObjectAndStoreToDisc<T>(string filePath, T serializableObject, bool overwrite = false)
+        where T : class
+    {
+        try
+        {
+            var fileInfo = FileSystem.FileInfo.New(filePath);
+            if (fileInfo.Exists && !overwrite)
+                throw new UnauthorizedAccessException(
+                    $"The file already exists. Force overwrite with {nameof(overwrite)}=true.");
+            fileInfo.Delete();
+
+            var directoyInfo = fileInfo.Directory;
+            if (directoyInfo is { Exists: false }) FileSystem.Directory.CreateDirectory(directoyInfo.FullName);
+
+            FileSystem.File.WriteAllText(filePath, SerializeObject(serializableObject));
+        }
+        catch (Exception e)
+        {
+            Logger.LogError("An exception occurred whilst serializing: {}", e);
+            return false;
+        }
+
+        return true;
+    }
+}

PG.Commons/PG.Commons/Data/Serialization/XmlSerializationSupportService.cs

@@ -1,6 +1,7 @@
 using AnakinRaW.CommonUtilities.Hashing;
 using Microsoft.Extensions.DependencyInjection;
 using PG.Commons.Attributes;
+using PG.Commons.Data.Serialization;
 using PG.Commons.Extensibility;
 using PG.Commons.Hashing;
 
@@ -16,5 +17,6 @@ public void ContributeServices(IServiceCollection serviceCollection)
     {
         serviceCollection.AddSingleton<IHashAlgorithmProvider>(sp => new Crc32HashingProvider());
         serviceCollection.AddSingleton<ICrc32HashingService>(sp => new Crc32HashingService(sp));
+        serviceCollection.AddSingleton<IXmlSerializationSupportService>(sp => new XmlSerializationSupportService(sp));
     }
 }

PG.Commons/PG.Commons/PGServiceContribution.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for details.
 
 using System;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 #if NETSTANDARD2_0
@@ -12,13 +13,14 @@
 namespace PG.Commons.Utilities;
 
 /// <summary>
-/// Provides primitive helper methods for strings.
+///     Provides primitive helper methods for strings.
 /// </summary>
 public static class StringUtilities
 {
     /// <summary>
-    /// Checks whether a given string, when converted to bytes, is not longer than the max value of an <see cref="ushort"/>.
-    /// Throws an <see cref="ArgumentException"/> if the string is longer.
+    ///     Checks whether a given string, when converted to bytes, is not longer than the max value of an
+    ///     <see cref="ushort" />.
+    ///     Throws an <see cref="ArgumentException" /> if the string is longer.
     /// </summary>
     /// <param name="value">The string to validate.</param>
     /// <param name="encoding">The encoding that shall be used to get the string length.</param>
@@ -32,17 +34,18 @@ public static ushort ValidateStringByteSizeUInt16(ReadOnlySpan<char> value, Enco
         if (encoding == null)
             throw new ArgumentNullException(nameof(encoding));
 
-        var size = encoding.GetByteCount(value);   
+        var size = encoding.GetByteCount(value);
 
         if (size is < 0 or > ushort.MaxValue)
-            throw new ArgumentException($"The value is longer than the expected {ushort.MaxValue} characters.", nameof(value));
+            throw new ArgumentException($"The value is longer than the expected {ushort.MaxValue} characters.",
+                nameof(value));
 
         return (ushort)size;
     }
 
     /// <summary>
-    /// Checks whether a given character sequence has no more characters than the max value of an <see cref="ushort"/>.
-    /// Throws an <see cref="ArgumentException"/> if the string is longer.
+    ///     Checks whether a given character sequence has no more characters than the max value of an <see cref="ushort" />.
+    ///     Throws an <see cref="ArgumentException" /> if the string is longer.
     /// </summary>
     /// <param name="value">The string to validate.</param>
     /// <returns>The actual length of the value in characters.</returns>
@@ -55,13 +58,14 @@ public static ushort ValidateStringCharLengthUInt16(ReadOnlySpan<char> value)
 
         var length = value.Length;
         if (length is < 0 or > ushort.MaxValue)
-            throw new ArgumentException($"The value is longer that the expected {ushort.MaxValue} characters.", nameof(value));
+            throw new ArgumentException($"The value is longer that the expected {ushort.MaxValue} characters.",
+                nameof(value));
 
         return (ushort)length;
     }
 
     /// <summary>
-    /// Throws an <see cref="ArgumentException"/> if the given character sequence contains non-ASCII characters.
+    ///     Throws an <see cref="ArgumentException" /> if the given character sequence contains non-ASCII characters.
     /// </summary>
     /// <param name="value">The character sequence to validate.</param>
     /// <exception cref="ArgumentException">The character sequence contains non-ASCII characters.</exception>
@@ -74,7 +78,7 @@ public static void ValidateIsAsciiOnly(ReadOnlySpan<char> value)
     }
 
     /// <summary>
-    /// Throws an <see cref="ArgumentException"/> if the given character sequence contains non-ASCII characters.
+    ///     Throws an <see cref="ArgumentException" /> if the given character sequence contains non-ASCII characters.
     /// </summary>
     /// <param name="value">The character sequence to validate.</param>
     /// <exception cref="ArgumentException">The character sequence contains non-ASCII characters.</exception>
@@ -85,10 +89,27 @@ public static bool IsAsciiOnly(ReadOnlySpan<char> value)
             throw new ArgumentNullException(nameof(value));
 
         foreach (var ch in value)
-        {
             if ((uint)ch > '\x007f')
                 return false;
-        }
         return true;
     }
-}
+
+    /// <summary>
+    ///     Basic validation algorithm.
+    /// </summary>
+    /// <param name="s"></param>
+    /// <returns></returns>
+    public static string Validate(string? s)
+    {
+        var stringBuilder = new StringBuilder();
+
+        if (string.IsNullOrEmpty(s)) return string.Empty;
+
+        foreach (var t in s.Where(t => t == 0x9 || t == 0xA || t == 0xD ||
+                                       (t >= 0x20 && t <= 0xD7FF) ||
+                                       (t >= 0xE000 && t <= 0xFFFD)))
+            stringBuilder.Append(t);
+
+        return stringBuilder.ToString();
+    }
+}

PG.Commons/PG.Commons/Utilities/StringUtilities.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Alamo Engine Tools and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+
+namespace PG.Commons.Utilities;
+
+/// <summary>
+///     XML file utility.
+/// </summary>
+public static class XmlUtilities
+{
+    /// <summary>
+    ///     Escape XML Content.
+    /// </summary>
+    /// <param name="s"></param>
+    /// <returns></returns>
+    public static string? EscapeXml(string? s)
+    {
+        if (string.IsNullOrEmpty(s)) return s;
+
+        var returnString = s!;
+        returnString = returnString.Replace("&", "&amp;");
+        returnString = returnString.Replace("<", "&lt;");
+        returnString = returnString.Replace(">", "&gt;");
+        returnString = returnString.Replace("'", "&apos;");
+        returnString = returnString.Replace("\"", "&quot;");
+        return returnString;
+    }
+
+    /// <summary>
+    ///     Unescape XML content.
+    /// </summary>
+    /// <param name="s"></param>
+    /// <returns></returns>
+    public static string? UnescapeXml(string? s)
+    {
+        if (string.IsNullOrEmpty(s)) return s;
+
+        var returnString = s!;
+        returnString = returnString.Replace("&apos;", "'");
+        returnString = returnString.Replace("&quot;", "\"");
+        returnString = returnString.Replace("&gt;", ">");
+        returnString = returnString.Replace("&lt;", "<");
+        returnString = returnString.Replace("&amp;", "&");
+        return returnString;
+    }
+}