move to string flags to xml serialization settings

popcron · popcron · commit 05ac3ab936f4 · 2025-06-07T11:37:48.000-04:00
diff --git a/source/JSON/SerializationSettings.cs b/source/JSON/SerializationSettings.cs
@@ -6,15 +6,15 @@ namespace Serialization.JSON
     public struct SerializationSettings
     {
         public const int DefaultIndentation = 4;
-        public static readonly SerializationSettings Default = new();
-        public static readonly SerializationSettings JSON5 = new(Flags.QuotelessNames | Flags.SingleQuotedText);
+        public static readonly SerializationSettings Default = new(Flags.None, 0);
+        public static readonly SerializationSettings JSON5 = new(Flags.QuotelessNames | Flags.SingleQuotedText, 0);
         public static readonly SerializationSettings PrettyPrinted = new(Flags.CarrierReturn | Flags.LineFeed | Flags.SpaceAfterColon, DefaultIndentation);
         public static readonly SerializationSettings JSON5PrettyPrinted = new(Flags.CarrierReturn | Flags.LineFeed | Flags.QuotelessNames | Flags.SingleQuotedText | Flags.SpaceAfterColon, DefaultIndentation);
 
         public Flags flags;
         public int indent;
 
-        public SerializationSettings(Flags flags, int indent = 0)
+        public SerializationSettings(Flags flags, int indent)
         {
             this.flags = flags;
             this.indent = indent;
diff --git a/source/Serialization.csproj b/source/Serialization.csproj
@@ -19,6 +19,10 @@
     <ItemGroup>
         <ProjectReference Include="..\..\collections\source\Collections.csproj"/>
         <ProjectReference Include="..\..\unmanaged\core\Unmanaged.Core.csproj"/>
+		<ProjectReference Include="..\..\unmanaged\generator\Unmanaged.Generator.csproj">
+			<OutputItemType>Analyzer</OutputItemType>
+			<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+		</ProjectReference>
     </ItemGroup>
 
 </Project>
diff --git a/source/XML/SerializationSettings.cs b/source/XML/SerializationSettings.cs
@@ -0,0 +1,57 @@
+﻿using System;
+using Unmanaged;
+
+namespace Serialization.XML
+{
+    public struct SerializationSettings
+    {
+        public const int DefaultIndentation = 2;
+        public static readonly SerializationSettings Default = new(default, 0);
+        public static readonly SerializationSettings PrettyPrinted = new(Flags.CarriageReturn | Flags.LineFeed, DefaultIndentation);
+
+        public Flags flags;
+        public int indent;
+
+        public SerializationSettings(Flags flags, int indent)
+        {
+            this.flags = flags;
+            this.indent = indent;
+        }
+
+        public readonly void Indent(Text text)
+        {
+            text.Append(' ', indent);
+        }
+
+        public readonly void Indent(ByteWriter writer)
+        {
+            for (int i = 0; i < indent; i++)
+            {
+                writer.WriteUTF8(' ');
+            }
+        }
+
+        public readonly void NewLine(Text text)
+        {
+            if ((flags & Flags.CarriageReturn) == Flags.CarriageReturn)
+            {
+                text.Append('\r');
+            }
+
+            if ((flags & Flags.LineFeed) == Flags.LineFeed)
+            {
+                text.Append('\n');
+            }
+        }
+
+        [Flags]
+        public enum Flags : byte
+        {
+            None = 0,
+            CarriageReturn = 1,
+            LineFeed = 2,
+            RootSpacing = 4,
+            SkipEmptyNodes = 8
+        }
+    }
+}
diff --git a/source/XML/ToStringFlags.cs b/source/XML/ToStringFlags.cs
diff --git a/source/XML/XMLNode.cs b/source/XML/XMLNode.cs
@@ -78,6 +78,9 @@ public readonly ReadOnlySpan<char> this[ReadOnlySpan<char> name]
         public readonly bool IsDisposed => name.IsDisposed;
 
 #if NET
+        /// <summary>
+        /// Creates an empty XML node.
+        /// </summary>
         public XMLNode()
         {
             name = new(4);
@@ -148,17 +151,16 @@ public void Dispose()
         public readonly override string ToString()
         {
             Text buffer = new(0);
-            ToStringFlags flags = ToStringFlags.CarriageReturn | ToStringFlags.LineFeed;
-            ToString(buffer, "  ", flags);
+            ToString(buffer, SerializationSettings.PrettyPrinted);
             string str = buffer.AsSpan().ToString();
             buffer.Dispose();
             return str;
         }
 
-        public readonly string ToString(string indent, ToStringFlags flags = default)
+        public readonly string ToString(SerializationSettings settings)
         {
             Text buffer = new(0);
-            ToString(buffer, indent, flags);
+            ToString(buffer, settings);
             string str = buffer.AsSpan().ToString();
             buffer.Dispose();
             return str;
@@ -167,8 +169,15 @@ public readonly string ToString(string indent, ToStringFlags flags = default)
         readonly void ISerializable.Write(ByteWriter writer)
         {
             Text buffer = new(0);
-            ToStringFlags flags = ToStringFlags.CarriageReturn | ToStringFlags.LineFeed;
-            ToString(buffer, default, flags, 0);
+            ToString(buffer, SerializationSettings.PrettyPrinted, 0);
+            writer.WriteSpan(buffer.AsSpan());
+            buffer.Dispose();
+        }
+
+        public readonly void Write(ByteWriter writer, SerializationSettings settings)
+        {
+            Text buffer = new(0);
+            ToString(buffer, settings, 0);
             writer.WriteSpan(buffer.AsSpan());
             buffer.Dispose();
         }
@@ -312,21 +321,16 @@ void ISerializable.Read(ByteReader reader)
             }
         }
 
-        public readonly void ToString(Text destination, ReadOnlySpan<char> indent = default, ToStringFlags flags = default)
+        public readonly void ToString(Text destination, SerializationSettings settings = default)
         {
-            ToString(destination, indent, flags, 0);
+            ToString(destination, settings, 0);
         }
 
-        public readonly void ToString(Text destination, string indent = "", ToStringFlags flags = default)
-        {
-            ToString(destination, indent.AsSpan(), flags, 0);
-        }
-
-        private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToStringFlags flags, byte depth)
+        private readonly void ToString(Text destination, SerializationSettings settings, byte depth)
         {
             for (int i = 0; i < depth; i++)
             {
-                Indent(indent);
+                settings.Indent(destination);
             }
 
             destination.Append('<');
@@ -336,14 +340,17 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt
             }
 
             destination.Append(Name);
-            for (int i = 0; i < attributes.Count; i++)
+
+            Span<XMLAttribute> attributesSpan = attributes.AsSpan();
+            for (int i = 0; i < attributesSpan.Length; i++)
             {
                 destination.Append(' ');
-                XMLAttribute attribute = attributes[i];
+                XMLAttribute attribute = attributesSpan[i];
                 attribute.ToString(destination);
             }
 
-            if (content.Length > 0 || children.Count > 0)
+            Span<XMLNode> childrenSpan = children.AsSpan();
+            if (content.Length > 0 || childrenSpan.Length > 0)
             {
                 if (prologue)
                 {
@@ -356,30 +363,37 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt
 
                 destination.Append('>');
                 destination.Append(Content);
-
-                if (children.Count > 0)
+                if (childrenSpan.Length > 0)
                 {
-                    foreach (XMLNode child in children)
+                    for (int c = 0; c < childrenSpan.Length; c++)
                     {
-                        if (depth == 1 && (flags & ToStringFlags.RootSpacing) == ToStringFlags.RootSpacing)
+                        XMLNode child = childrenSpan[c];
+                        if ((settings.flags & SerializationSettings.Flags.SkipEmptyNodes) == SerializationSettings.Flags.SkipEmptyNodes)
+                        {
+                            if (child.content.Length == 0 && child.children.Count == 0 && child.attributes.Count == 0)
+                            {
+                                continue;
+                            }
+                        }
+
+                        if (depth == 1 && (settings.flags & SerializationSettings.Flags.RootSpacing) == SerializationSettings.Flags.RootSpacing)
                         {
-                            NewLine();
+                            settings.NewLine(destination);
                         }
 
-                        NewLine();
-                        child.ToString(destination, indent, flags, depth);
+                        settings.NewLine(destination);
+                        child.ToString(destination, settings, depth);
                     }
 
-
-                    if (depth == 1 && (flags & ToStringFlags.RootSpacing) == ToStringFlags.RootSpacing)
+                    if (depth == 1 && (settings.flags & SerializationSettings.Flags.RootSpacing) == SerializationSettings.Flags.RootSpacing)
                     {
-                        NewLine();
+                        settings.NewLine(destination);
                     }
 
-                    NewLine();
+                    settings.NewLine(destination);
                     for (int i = 0; i < depth - 1; i++)
                     {
-                        Indent(indent);
+                        settings.Indent(destination);
                     }
                 }
 
@@ -396,24 +410,6 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt
                 destination.Append('/');
                 destination.Append('>');
             }
-
-            void NewLine()
-            {
-                if ((flags & ToStringFlags.CarriageReturn) == ToStringFlags.CarriageReturn)
-                {
-                    destination.Append('\r');
-                }
-
-                if ((flags & ToStringFlags.LineFeed) == ToStringFlags.LineFeed)
-                {
-                    destination.Append('\n');
-                }
-            }
-
-            void Indent(ReadOnlySpan<char> indent)
-            {
-                destination.Append(indent);
-            }
         }
 
         /// <summary>
diff --git a/source/XML/XMLReader.cs b/source/XML/XMLReader.cs
@@ -103,7 +103,7 @@ public readonly bool PeekToken(int position, out Token token)
                             }
                             else if (!char.IsLetterOrDigit(c))
                             {
-                                throw new Exception($"Invalid XML, unknown symbol '{c}' inside node");
+                                throw new Exception($"Invalid XML, unknown symbol `{c}` inside node");
                             }
                         }
 
diff --git a/tests/Serialization.Tests.csproj b/tests/Serialization.Tests.csproj
@@ -37,6 +37,10 @@
 		<ProjectReference Include="..\..\unmanaged\tests\Unmanaged.Tests.csproj" />
 		<ProjectReference Include="..\source\Serialization.csproj" />
 		<ProjectReference Include="..\..\unmanaged\core\Unmanaged.Core.csproj" />
+		<ProjectReference Include="..\..\unmanaged\generator\Unmanaged.Generator.csproj">
+			<OutputItemType>Analyzer</OutputItemType>
+			<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+		</ProjectReference>
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/tests/XMLTests.cs b/tests/XMLTests.cs
@@ -89,7 +89,7 @@ public void EmptyNode()
 
             reader.Position = 0;
             using XMLNode node = reader.ReadObject<XMLNode>();
-            string str = node.ToString("");
+            string str = node.ToString(SerializationSettings.Default);
             Assert.That(str, Is.EqualTo(Sample));
         }
 
@@ -149,5 +149,26 @@ public void ReadWithPrologue()
             using XMLNode node = xmlReader.ReadNode();
             Assert.That(node.IsPrologue, Is.True);
         }
+
+        [Test]
+        public void SkipEmptyNodes()
+        {
+            using XMLNode node = new("Root");
+            node.Add(new("Name", "Boa"));
+            node.Add(new("Type", "Box"));
+            node.Add(new("Empty"));
+
+            SerializationSettings settings = SerializationSettings.PrettyPrinted;
+            settings.flags |= SerializationSettings.Flags.SkipEmptyNodes;
+
+            using ByteReader reader = ByteReader.CreateFromUTF8(node.ToString(settings));
+            using XMLNode readNode = reader.ReadObject<XMLNode>();
+            Assert.That(readNode.Name.ToString(), Is.EqualTo("Root"));
+            Assert.That(readNode.Children.Length, Is.EqualTo(2));
+            Assert.That(readNode.Children[0].Name.ToString(), Is.EqualTo("Name"));
+            Assert.That(readNode.Children[0].Content.ToString(), Is.EqualTo("Boa"));
+            Assert.That(readNode.Children[1].Name.ToString(), Is.EqualTo("Type"));
+            Assert.That(readNode.Children[1].Content.ToString(), Is.EqualTo("Box"));
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,9 @@ public readonly ReadOnlySpan<char> this[ReadOnlySpan<char> name]`
`78`	`78`	`public readonly bool IsDisposed => name.IsDisposed;`
`79`	`79`
`80`	`80`	`#if NET`
	`81`	`+ /// <summary>`
	`82`	`+ /// Creates an empty XML node.`
	`83`	`+ /// </summary>`
`81`	`84`	`public XMLNode()`
`82`	`85`	`{`
`83`	`86`	`name = new(4);`
`@@ -148,17 +151,16 @@ public void Dispose()`
`148`	`151`	`public readonly override string ToString()`
`149`	`152`	`{`
`150`	`153`	`Text buffer = new(0);`
`151`		`- ToStringFlags flags = ToStringFlags.CarriageReturn \| ToStringFlags.LineFeed;`
`152`		`- ToString(buffer, " ", flags);`
	`154`	`+ ToString(buffer, SerializationSettings.PrettyPrinted);`
`153`	`155`	`string str = buffer.AsSpan().ToString();`
`154`	`156`	`buffer.Dispose();`
`155`	`157`	`return str;`
`156`	`158`	`}`
`157`	`159`
`158`		`- public readonly string ToString(string indent, ToStringFlags flags = default)`
	`160`	`+ public readonly string ToString(SerializationSettings settings)`
`159`	`161`	`{`
`160`	`162`	`Text buffer = new(0);`
`161`		`- ToString(buffer, indent, flags);`
	`163`	`+ ToString(buffer, settings);`
`162`	`164`	`string str = buffer.AsSpan().ToString();`
`163`	`165`	`buffer.Dispose();`
`164`	`166`	`return str;`
`@@ -167,8 +169,15 @@ public readonly string ToString(string indent, ToStringFlags flags = default)`
`167`	`169`	`readonly void ISerializable.Write(ByteWriter writer)`
`168`	`170`	`{`
`169`	`171`	`Text buffer = new(0);`
`170`		`- ToStringFlags flags = ToStringFlags.CarriageReturn \| ToStringFlags.LineFeed;`
`171`		`- ToString(buffer, default, flags, 0);`
	`172`	`+ ToString(buffer, SerializationSettings.PrettyPrinted, 0);`
	`173`	`+ writer.WriteSpan(buffer.AsSpan());`
	`174`	`+ buffer.Dispose();`
	`175`	`+ }`
	`176`	`+`
	`177`	`+ public readonly void Write(ByteWriter writer, SerializationSettings settings)`
	`178`	`+ {`
	`179`	`+ Text buffer = new(0);`
	`180`	`+ ToString(buffer, settings, 0);`
`172`	`181`	`writer.WriteSpan(buffer.AsSpan());`
`173`	`182`	`buffer.Dispose();`
`174`	`183`	`}`
`@@ -312,21 +321,16 @@ void ISerializable.Read(ByteReader reader)`
`312`	`321`	`}`
`313`	`322`	`}`
`314`	`323`
`315`		`- public readonly void ToString(Text destination, ReadOnlySpan<char> indent = default, ToStringFlags flags = default)`
	`324`	`+ public readonly void ToString(Text destination, SerializationSettings settings = default)`
`316`	`325`	`{`
`317`		`- ToString(destination, indent, flags, 0);`
	`326`	`+ ToString(destination, settings, 0);`
`318`	`327`	`}`
`319`	`328`
`320`		`- public readonly void ToString(Text destination, string indent = "", ToStringFlags flags = default)`
`321`		`- {`
`322`		`- ToString(destination, indent.AsSpan(), flags, 0);`
`323`		`- }`
`324`		`-`
`325`		`- private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToStringFlags flags, byte depth)`
	`329`	`+ private readonly void ToString(Text destination, SerializationSettings settings, byte depth)`
`326`	`330`	`{`
`327`	`331`	`for (int i = 0; i < depth; i++)`
`328`	`332`	`{`
`329`		`- Indent(indent);`
	`333`	`+ settings.Indent(destination);`
`330`	`334`	`}`
`331`	`335`
`332`	`336`	`destination.Append('<');`
`@@ -336,14 +340,17 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt`
`336`	`340`	`}`
`337`	`341`
`338`	`342`	`destination.Append(Name);`
`339`		`- for (int i = 0; i < attributes.Count; i++)`
	`343`	`+`
	`344`	`+ Span<XMLAttribute> attributesSpan = attributes.AsSpan();`
	`345`	`+ for (int i = 0; i < attributesSpan.Length; i++)`
`340`	`346`	`{`
`341`	`347`	`destination.Append(' ');`
`342`		`- XMLAttribute attribute = attributes[i];`
	`348`	`+ XMLAttribute attribute = attributesSpan[i];`
`343`	`349`	`attribute.ToString(destination);`
`344`	`350`	`}`
`345`	`351`
`346`		`- if (content.Length > 0 \|\| children.Count > 0)`
	`352`	`+ Span<XMLNode> childrenSpan = children.AsSpan();`
	`353`	`+ if (content.Length > 0 \|\| childrenSpan.Length > 0)`
`347`	`354`	`{`
`348`	`355`	`if (prologue)`
`349`	`356`	`{`
`@@ -356,30 +363,37 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt`
`356`	`363`
`357`	`364`	`destination.Append('>');`
`358`	`365`	`destination.Append(Content);`
`359`		`-`
`360`		`- if (children.Count > 0)`
	`366`	`+ if (childrenSpan.Length > 0)`
`361`	`367`	`{`
`362`		`- foreach (XMLNode child in children)`
	`368`	`+ for (int c = 0; c < childrenSpan.Length; c++)`
`363`	`369`	`{`
`364`		`- if (depth == 1 && (flags & ToStringFlags.RootSpacing) == ToStringFlags.RootSpacing)`
	`370`	`+ XMLNode child = childrenSpan[c];`
	`371`	`+ if ((settings.flags & SerializationSettings.Flags.SkipEmptyNodes) == SerializationSettings.Flags.SkipEmptyNodes)`
	`372`	`+ {`
	`373`	`+ if (child.content.Length == 0 && child.children.Count == 0 && child.attributes.Count == 0)`
	`374`	`+ {`
	`375`	`+ continue;`
	`376`	`+ }`
	`377`	`+ }`
	`378`	`+`
	`379`	`+ if (depth == 1 && (settings.flags & SerializationSettings.Flags.RootSpacing) == SerializationSettings.Flags.RootSpacing)`
`365`	`380`	`{`
`366`		`- NewLine();`
	`381`	`+ settings.NewLine(destination);`
`367`	`382`	`}`
`368`	`383`
`369`		`- NewLine();`
`370`		`- child.ToString(destination, indent, flags, depth);`
	`384`	`+ settings.NewLine(destination);`
	`385`	`+ child.ToString(destination, settings, depth);`
`371`	`386`	`}`
`372`	`387`
`373`		`-`
`374`		`- if (depth == 1 && (flags & ToStringFlags.RootSpacing) == ToStringFlags.RootSpacing)`
	`388`	`+ if (depth == 1 && (settings.flags & SerializationSettings.Flags.RootSpacing) == SerializationSettings.Flags.RootSpacing)`
`375`	`389`	`{`
`376`		`- NewLine();`
	`390`	`+ settings.NewLine(destination);`
`377`	`391`	`}`
`378`	`392`
`379`		`- NewLine();`
	`393`	`+ settings.NewLine(destination);`
`380`	`394`	`for (int i = 0; i < depth - 1; i++)`
`381`	`395`	`{`
`382`		`- Indent(indent);`
	`396`	`+ settings.Indent(destination);`
`383`	`397`	`}`
`384`	`398`	`}`
`385`	`399`
`@@ -396,24 +410,6 @@ private readonly void ToString(Text destination, ReadOnlySpan<char> indent, ToSt`
`396`	`410`	`destination.Append('/');`
`397`	`411`	`destination.Append('>');`
`398`	`412`	`}`
`399`		`-`
`400`		`- void NewLine()`
`401`		`- {`
`402`		`- if ((flags & ToStringFlags.CarriageReturn) == ToStringFlags.CarriageReturn)`
`403`		`- {`
`404`		`- destination.Append('\r');`
`405`		`- }`
`406`		`-`
`407`		`- if ((flags & ToStringFlags.LineFeed) == ToStringFlags.LineFeed)`
`408`		`- {`
`409`		`- destination.Append('\n');`
`410`		`- }`
`411`		`- }`
`412`		`-`
`413`		`- void Indent(ReadOnlySpan<char> indent)`
`414`		`- {`
`415`		`- destination.Append(indent);`
`416`		`- }`
`417`	`413`	`}`
`418`	`414`
`419`	`415`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public readonly bool PeekToken(int position, out Token token)`
`103`	`103`	`}`
`104`	`104`	`else if (!char.IsLetterOrDigit(c))`
`105`	`105`	`{`
`106`		`- throw new Exception($"Invalid XML, unknown symbol '{c}' inside node");`
	`106`	+ throw new Exception($"Invalid XML, unknown symbol `{c}` inside node");
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`