Changeset 1330 for branches/New Persistence Exploration/Persistence/Persistence/XmlFormatter.cs

Timestamp:

03/12/09 12:19:32 (15 years ago)

Author:

epitzer

Message:

More compact XML Formatting (no empty names, referencable primitives, compact arrays & lists). (#506)

File:

• branches/New Persistence Exploration/Persistence/Persistence/XmlFormatter.cs (modified) (3 diffs)

branches/New Persistence Exploration/Persistence/Persistence/XmlFormatter.cs

@@ -1 +1 @@
 using System.Collections.Generic;
 using System;
+using System.Xml;
+using System.Text;
 namespace Persistence {
   public class XmlFormatter {
@@ -13 +15 @@
                        {typeof (BeginToken), FormatBegin},
                        {typeof (EndToken), FormatEnd},
-                       {typeof (PrimitiveToken), FormatData},
+                       {typeof (PrimitiveToken), FormatPrimitive},
                        {typeof (ReferenceToken), FormatReference},
                        {typeof (NullReferenceToken), FormatNullReference}
                      };
       depth = 0;
+    }
+
+    private enum NodeType { Start, End, Inline } ;
+
+    private static string FormatNode(string name, Dictionary<string, string> attributes, NodeType type) {
+      StringBuilder sb = new StringBuilder();
+      sb.Append('<');
+      if (type == NodeType.End)
+        sb.Append('/');
+      sb.Append(name);      
+      foreach (var attribute in attributes) {
+        sb.Append(' ');
+        sb.Append(attribute.Key);
+        sb.Append("=\"");
+        sb.Append(attribute.Value);
+        sb.Append('"');
+      }
+      if (type == NodeType.Inline)
+        sb.Append('/');
+      sb.Append(">");
+      return sb.ToString();      
     }
 
@@ -30 +53 @@
     private string FormatBegin(ISerializationToken token) {
       BeginToken beginToken = (BeginToken)token;
-      string result =
-        String.Format("{0}<COMPOSITE name=\"{1}\" type=\"{2}\" id=\"{3}\">\n",
-          Prefix, beginToken.Accessor.Name, beginToken.Accessor.Get().GetType(), beginToken.Id);
+      string result = Prefix +
+                      FormatNode("COMPOSITE",
+                                 new Dictionary<string, string>
+                                   {
+                                     {"name", beginToken.Accessor.Name},
+                                     {"type", beginToken.Accessor.Get().GetType().ToString()},
+                                     {"id", beginToken.Id.ToString()}
+                                   }, NodeType.Start) + "\n";
       depth += 1;
       return result;
     }
 
-    private string FormatEnd(ISerializationToken token) {
+    private string FormatEnd(ISerializationToken token) {      
       depth -= 1;
       return Prefix + "</COMPOSITE>\n";
     }
 
-    private string FormatData(ISerializationToken token) {
+    private string FormatPrimitive(ISerializationToken token) {
       PrimitiveToken dataToken = (PrimitiveToken)token;
-      return String.Format("{0}<PRIMITIVE name=\"{1}\" type=\"{2}\">{3}</PRIMITIVE>\n",
-        Prefix, dataToken.accessor.Name, dataToken.accessor.Get().GetType(), dataToken.Data);
+      Dictionary<string, string> attributes =
+        new Dictionary<string, string> {
+            {"type", dataToken.Accessor.Get().GetType().ToString()}};
+      if ( dataToken.Accessor.Name != "" )
+        attributes.Add("name", dataToken.Accessor.Name);
+      if ( dataToken.Id != null )
+        attributes.Add("id", dataToken.Id.ToString());
+      return Prefix +
+        FormatNode("PRIMITIVE", attributes, NodeType.Start) +
+        dataToken.Data + "</PRIMITIVE>\n";      
     }
 
     private string FormatReference(ISerializationToken token) {
-      ReferenceToken refToken = (ReferenceToken)token;
-      return String.Format("{0}<REFERENCE name=\"{1}\" ref=\"{2}\"/>\n",
-        Prefix, refToken.Name, refToken.Id);
+      ReferenceToken refToken = (ReferenceToken) token;
+      Dictionary<string, string> attributes =
+        new Dictionary<string, string> {{"ref", refToken.Id.ToString()}};
+      if ( refToken.Name != null )
+        attributes.Add("name", refToken.Name);
+      return Prefix + FormatNode("REFERENCE", attributes, NodeType.Inline) + "\n";  
     }
 
     private string FormatNullReference(ISerializationToken token) {
       NullReferenceToken nullRefToken = (NullReferenceToken)token;
-      return String.Format("{0}<NULL name=\"{1}\"/>\n",
-        Prefix, nullRefToken.Name);
+      Dictionary<string, string> attributes = new Dictionary<string, string>();
+      if (nullRefToken.Name != null)
+        attributes.Add("name", nullRefToken.Name);
+      return Prefix + FormatNode("NULL", attributes, NodeType.Inline) + "\n";
     }
   }