Changeset 1570


Ignore:
Timestamp:
04/16/09 16:10:39 (12 years ago)
Author:
epitzer
Message:

Streamline XML generation with StringBuilders (#548)

Location:
trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs

    r1566 r1570  
    11using System;
    2 using System.Text;
    32using HeuristicLab.Persistence.Core;
    43using HeuristicLab.Persistence.Interfaces;
    5 using System.Xml;
     4using System.Text;
     5
    66
    77namespace HeuristicLab.Persistence.Default.Xml.Primitive {
     
    1010  public class String2XmlFormatter : FormatterBase<string, XmlString> {
    1111
    12     public override XmlString Format(string s) {
     12    public override XmlString Format(string s) {     
    1313      StringBuilder sb = new StringBuilder();
    1414      sb.Append("<![CDATA[");
     
    2020    private static readonly string[] separators = new string[] { "<![CDATA[", "]]>" };
    2121
    22     public override string Parse(XmlString x) {
     22    public override string Parse(XmlString x) {     
    2323      StringBuilder sb = new StringBuilder();
    2424      foreach (string s in x.Data.Split(separators,
  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

    r1566 r1570  
    2525
    2626    private int depth;
     27    private int Depth {
     28      get {
     29        return depth;
     30      }
     31      set {
     32        depth = value;
     33        prefix = new string(' ', depth * 2);
     34      }
     35    }
     36
     37    private string prefix;
     38
    2739
    2840    public XmlGenerator() {
    29       depth = 0;
     41      Depth = 0;
    3042    }
    3143
    3244    private enum NodeType { Start, End, Inline } ;
    3345
    34     private static string FormatNode(string name,
    35         Dictionary<string, object> attributes,
    36         NodeType type) {
    37       return FormatNode(name, attributes, type, " ");
    38     }
    39 
    40     private static string FormatNode(string name,
    41         Dictionary<string, object> attributes,
    42         NodeType type, string space) {
    43       StringBuilder sb = new StringBuilder();
    44       sb.Append('<');
    45       if (type == NodeType.End)
    46         sb.Append('/');
     46    private static void AddXmlTagContent(StringBuilder sb, string name, Dictionary<string, object> attributes) {
    4747      sb.Append(name);
    4848      foreach (var attribute in attributes) {
    4949        if (attribute.Value != null && !string.IsNullOrEmpty(attribute.Value.ToString())) {
    50           sb.Append(space);
     50          sb.Append(' ');
    5151          sb.Append(attribute.Key);
    5252          sb.Append("=\"");
     
    5555        }
    5656      }
    57       if (type == NodeType.Inline)
    58         sb.Append('/');
     57    }
     58
     59    private static void AddXmlStartTag(StringBuilder sb, string name, Dictionary<string, object> attributes) {
     60      sb.Append('<');
     61      AddXmlTagContent(sb, name, attributes);
     62      sb.Append('>');
     63    }
     64
     65    private static void AddXmlInlineTag(StringBuilder sb, string name, Dictionary<string, object> attributes) {
     66      sb.Append('<');
     67      AddXmlTagContent(sb, name, attributes);
     68      sb.Append("/>");
     69    }
     70
     71    private static void AddXmlEndTag(StringBuilder sb, string name) {
     72      sb.Append("</");
     73      sb.Append(name);
    5974      sb.Append(">");
     75    }
     76
     77    private string CreateNodeStart(string name, Dictionary<string, object> attributes) {
     78      StringBuilder sb = new StringBuilder();
     79      sb.Append(prefix);
     80      Depth += 1;
     81      AddXmlStartTag(sb, name, attributes);
     82      sb.Append("\r\n");
    6083      return sb.ToString();
    6184    }
    6285
    63     private string Prefix {
    64       get { return new string(' ', depth * 2); }
     86    private string CreateNodeStart(string name) {
     87      return CreateNodeStart(name, new Dictionary<string, object>());
     88    }
     89
     90    private string CreateNodeEnd(string name) {
     91      Depth -= 1;
     92      StringBuilder sb = new StringBuilder();
     93      sb.Append(prefix);
     94      AddXmlEndTag(sb, name);
     95      sb.Append("\r\n");
     96      return sb.ToString();
     97    }
     98
     99    private string CreateNode(string name, Dictionary<string, object> attributes) {
     100      StringBuilder sb = new StringBuilder();
     101      sb.Append(prefix);
     102      AddXmlInlineTag(sb, name, attributes);
     103      sb.Append("\r\n");
     104      return sb.ToString();
     105    }
     106
     107    private string CreateNode(string name, Dictionary<string, object> attributes, string content) {
     108      StringBuilder sb = new StringBuilder();
     109      sb.Append(prefix);
     110      AddXmlStartTag(sb, name, attributes);
     111      sb.Append(content);
     112      sb.Append("</").Append(name).Append(">\r\n");
     113      return sb.ToString();
    65114    }
    66115
    67116    protected override string Format(BeginToken beginToken) {
    68       var attributes = new Dictionary<string, object> {
    69         {"name", beginToken.Name},
    70         {"typeId", beginToken.TypeId},
    71         {"id", beginToken.Id}};
    72       string result = Prefix +
    73                       FormatNode(XmlStrings.COMPOSITE, attributes, NodeType.Start) + "\r\n";
    74       depth += 1;
    75       return result;
     117      return CreateNodeStart(
     118        XmlStrings.COMPOSITE,
     119        new Dictionary<string, object> {
     120          {"name", beginToken.Name},
     121          {"typeId", beginToken.TypeId},
     122          {"id", beginToken.Id}});
    76123    }
    77124
    78125    protected override string Format(EndToken endToken) {
    79       depth -= 1;
    80       return Prefix + "</" + XmlStrings.COMPOSITE + ">\r\n";
     126      return CreateNodeEnd(XmlStrings.COMPOSITE);
    81127    }
    82128
    83129    protected override string Format(PrimitiveToken dataToken) {
    84       var attributes =
     130      return CreateNode(XmlStrings.PRIMITIVE,
    85131        new Dictionary<string, object> {
    86132            {"typeId", dataToken.TypeId},
    87133            {"name", dataToken.Name},
    88             {"id", dataToken.Id}};
    89       return Prefix +
    90         FormatNode(XmlStrings.PRIMITIVE, attributes, NodeType.Start) +
    91         ((XmlString)dataToken.SerialData).Data + "</" + XmlStrings.PRIMITIVE + ">\r\n";
     134            {"id", dataToken.Id}},
     135        ((XmlString)dataToken.SerialData).Data);
    92136    }
    93137
    94138    protected override string Format(ReferenceToken refToken) {
    95       var attributes = new Dictionary<string, object> {
    96         {"ref", refToken.Id},
    97         {"name", refToken.Name}};
    98       return Prefix + FormatNode(XmlStrings.REFERENCE, attributes, NodeType.Inline) + "\r\n";
     139      return CreateNode(XmlStrings.REFERENCE,
     140        new Dictionary<string, object> {
     141          {"ref", refToken.Id},
     142          {"name", refToken.Name}});
    99143    }
    100144
    101145    protected override string Format(NullReferenceToken nullRefToken) {
    102       var attributes = new Dictionary<string, object>{
    103         {"name", nullRefToken.Name}};
    104       return Prefix + FormatNode(XmlStrings.NULL, attributes, NodeType.Inline) + "\r\n";
     146      return CreateNode(XmlStrings.NULL,
     147        new Dictionary<string, object>{
     148          {"name", nullRefToken.Name}});
    105149    }
    106150
    107151    protected override string Format(MetaInfoBeginToken metaInfoBeginToken) {
    108       string result = Prefix + "<" + XmlStrings.METAINFO + ">\r\n";
    109       depth += 1;
    110       return result;
     152      return CreateNodeStart(XmlStrings.METAINFO);
    111153    }
    112154
    113155    protected override string Format(MetaInfoEndToken metaInfoEndToken) {
    114       depth -= 1;
    115       return Prefix + "</" + XmlStrings.METAINFO + ">\r\n";
     156      return CreateNodeEnd(XmlStrings.METAINFO);
    116157    }
    117158
    118159    public IEnumerable<string> Format(List<TypeMapping> typeCache) {
    119       yield return "<" + XmlStrings.TYPECACHE + ">";
     160      yield return CreateNodeStart(XmlStrings.TYPECACHE);
    120161      foreach (var mapping in typeCache)
    121         yield return "  " + FormatNode(
     162        yield return CreateNode(
    122163          XmlStrings.TYPE,
    123           mapping.GetDict(),
    124           NodeType.Inline,
    125           "\r\n    ");
    126       yield return "</" + XmlStrings.TYPECACHE + ">";
     164          mapping.GetDict());
     165      yield return CreateNodeEnd(XmlStrings.TYPECACHE);
    127166    }
    128167
     
    142181        string line = generator.Format(token);
    143182        writer.Write(line);
    144         logger.Debug(line);
     183        logger.Debug(line.TrimEnd());
    145184      }
    146185      writer.Flush();
     
    149188      foreach (string line in generator.Format(serializer.TypeCache)) {
    150189        writer.WriteLine(line);
    151         logger.Debug(line);
     190        logger.Debug(line.TrimEnd());
    152191      }
    153192      writer.Flush();
Note: See TracChangeset for help on using the changeset viewer.