Changeset 1570

Timestamp:

04/16/09 16:10:39 (16 years ago)

Author:

epitzer

Message:

Streamline XML generation with StringBuilders (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml

Files:

• Primitive/String2XmlFormatter.cs (modified) (3 diffs)
• XmlGenerator.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs

@@ -1 +1 @@
 using System;
-using System.Text;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
-using System.Xml;
+using System.Text;
+
 
 namespace HeuristicLab.Persistence.Default.Xml.Primitive {
@@ -10 +10 @@
   public class String2XmlFormatter : FormatterBase<string, XmlString> {
 
-    public override XmlString Format(string s) {
+    public override XmlString Format(string s) {      
       StringBuilder sb = new StringBuilder();
       sb.Append("<![CDATA[");
@@ -20 +20 @@
     private static readonly string[] separators = new string[] { "<![CDATA[", "]]>" };
 
-    public override string Parse(XmlString x) {
+    public override string Parse(XmlString x) {      
       StringBuilder sb = new StringBuilder();
       foreach (string s in x.Data.Split(separators,

trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

@@ -25 +25 @@
 
     private int depth;
+    private int Depth {
+      get {
+        return depth;
+      }
+      set {
+        depth = value;
+        prefix = new string(' ', depth * 2);
+      }
+    }
+
+    private string prefix;
+
 
     public XmlGenerator() {
-      depth = 0;
+      Depth = 0;
     }
 
     private enum NodeType { Start, End, Inline } ;
 
-    private static string FormatNode(string name,
-        Dictionary<string, object> attributes,
-        NodeType type) {
-      return FormatNode(name, attributes, type, " ");
-    }
-
-    private static string FormatNode(string name,
-        Dictionary<string, object> attributes,
-        NodeType type, string space) {
-      StringBuilder sb = new StringBuilder();
-      sb.Append('<');
-      if (type == NodeType.End)
-        sb.Append('/');
+    private static void AddXmlTagContent(StringBuilder sb, string name, Dictionary<string, object> attributes) {
       sb.Append(name);
       foreach (var attribute in attributes) {
         if (attribute.Value != null && !string.IsNullOrEmpty(attribute.Value.ToString())) {
-          sb.Append(space);
+          sb.Append(' ');
           sb.Append(attribute.Key);
           sb.Append("=\"");
@@ -55 +55 @@
         }
       }
-      if (type == NodeType.Inline)
-        sb.Append('/');
+    }
+
+    private static void AddXmlStartTag(StringBuilder sb, string name, Dictionary<string, object> attributes) {
+      sb.Append('<');
+      AddXmlTagContent(sb, name, attributes);
+      sb.Append('>');
+    }
+
+    private static void AddXmlInlineTag(StringBuilder sb, string name, Dictionary<string, object> attributes) {
+      sb.Append('<');
+      AddXmlTagContent(sb, name, attributes);
+      sb.Append("/>");
+    }
+
+    private static void AddXmlEndTag(StringBuilder sb, string name) {
+      sb.Append("</");
+      sb.Append(name);
       sb.Append(">");
+    }
+
+    private string CreateNodeStart(string name, Dictionary<string, object> attributes) {
+      StringBuilder sb = new StringBuilder();
+      sb.Append(prefix);
+      Depth += 1;
+      AddXmlStartTag(sb, name, attributes);
+      sb.Append("\r\n");
       return sb.ToString();
     }
 
-    private string Prefix {
-      get { return new string(' ', depth * 2); }
+    private string CreateNodeStart(string name) {
+      return CreateNodeStart(name, new Dictionary<string, object>());
+    }
+
+    private string CreateNodeEnd(string name) {
+      Depth -= 1;
+      StringBuilder sb = new StringBuilder();
+      sb.Append(prefix);
+      AddXmlEndTag(sb, name);
+      sb.Append("\r\n");
+      return sb.ToString();
+    }
+
+    private string CreateNode(string name, Dictionary<string, object> attributes) {
+      StringBuilder sb = new StringBuilder();
+      sb.Append(prefix);
+      AddXmlInlineTag(sb, name, attributes);
+      sb.Append("\r\n");
+      return sb.ToString();
+    }
+
+    private string CreateNode(string name, Dictionary<string, object> attributes, string content) {
+      StringBuilder sb = new StringBuilder();
+      sb.Append(prefix);
+      AddXmlStartTag(sb, name, attributes);
+      sb.Append(content);
+      sb.Append("</").Append(name).Append(">\r\n");
+      return sb.ToString();
     }
 
     protected override string Format(BeginToken beginToken) {
-      var attributes = new Dictionary<string, object> {
-        {"name", beginToken.Name},
-        {"typeId", beginToken.TypeId},
-        {"id", beginToken.Id}};
-      string result = Prefix +
-                      FormatNode(XmlStrings.COMPOSITE, attributes, NodeType.Start) + "\r\n";
-      depth += 1;
-      return result;
+      return CreateNodeStart(
+        XmlStrings.COMPOSITE,
+        new Dictionary<string, object> {
+          {"name", beginToken.Name},
+          {"typeId", beginToken.TypeId},
+          {"id", beginToken.Id}});
     }
 
     protected override string Format(EndToken endToken) {
-      depth -= 1;
-      return Prefix + "</" + XmlStrings.COMPOSITE + ">\r\n";
+      return CreateNodeEnd(XmlStrings.COMPOSITE);
     }
 
     protected override string Format(PrimitiveToken dataToken) {
-      var attributes =
+      return CreateNode(XmlStrings.PRIMITIVE,
         new Dictionary<string, object> {
             {"typeId", dataToken.TypeId},
             {"name", dataToken.Name},
-            {"id", dataToken.Id}};
-      return Prefix +
-        FormatNode(XmlStrings.PRIMITIVE, attributes, NodeType.Start) +
-        ((XmlString)dataToken.SerialData).Data + "</" + XmlStrings.PRIMITIVE + ">\r\n";
+            {"id", dataToken.Id}},
+        ((XmlString)dataToken.SerialData).Data);
     }
 
     protected override string Format(ReferenceToken refToken) {
-      var attributes = new Dictionary<string, object> {
-        {"ref", refToken.Id},
-        {"name", refToken.Name}};
-      return Prefix + FormatNode(XmlStrings.REFERENCE, attributes, NodeType.Inline) + "\r\n";
+      return CreateNode(XmlStrings.REFERENCE,
+        new Dictionary<string, object> {
+          {"ref", refToken.Id},
+          {"name", refToken.Name}});
     }
 
     protected override string Format(NullReferenceToken nullRefToken) {
-      var attributes = new Dictionary<string, object>{
-        {"name", nullRefToken.Name}};
-      return Prefix + FormatNode(XmlStrings.NULL, attributes, NodeType.Inline) + "\r\n";
+      return CreateNode(XmlStrings.NULL,
+        new Dictionary<string, object>{
+          {"name", nullRefToken.Name}});
     }
 
     protected override string Format(MetaInfoBeginToken metaInfoBeginToken) {
-      string result = Prefix + "<" + XmlStrings.METAINFO + ">\r\n";
-      depth += 1;
-      return result;
+      return CreateNodeStart(XmlStrings.METAINFO);
     }
 
     protected override string Format(MetaInfoEndToken metaInfoEndToken) {
-      depth -= 1;
-      return Prefix + "</" + XmlStrings.METAINFO + ">\r\n";
+      return CreateNodeEnd(XmlStrings.METAINFO);
     }
 
     public IEnumerable<string> Format(List<TypeMapping> typeCache) {
-      yield return "<" + XmlStrings.TYPECACHE + ">";
+      yield return CreateNodeStart(XmlStrings.TYPECACHE);
       foreach (var mapping in typeCache)
-        yield return "  " + FormatNode(
+        yield return CreateNode(
           XmlStrings.TYPE,
-          mapping.GetDict(),
-          NodeType.Inline,
-          "\r\n    ");
-      yield return "</" + XmlStrings.TYPECACHE + ">";
+          mapping.GetDict());
+      yield return CreateNodeEnd(XmlStrings.TYPECACHE);
     }
 
@@ -142 +181 @@
         string line = generator.Format(token);
         writer.Write(line);
-        logger.Debug(line);
+        logger.Debug(line.TrimEnd());
       }
       writer.Flush();
@@ -149 +188 @@
       foreach (string line in generator.Format(serializer.TypeCache)) {
         writer.WriteLine(line);
-        logger.Debug(line);
+        logger.Debug(line.TrimEnd());
       }
       writer.Flush();