source: branches/New Persistence Exploration/Persistence/Persistence/XmlFormatter.cs @ 1357

using System.Collections.Generic;
using System;
using System.Text;
using HeuristicLab.Persistence.Interfaces;

namespace HeuristicLab.Persistence {
  public class XmlFormatter {

    delegate string Formatter(ISerializationToken token);

    private readonly Dictionary<Type, Formatter> formatters;
    private int depth;

    public XmlFormatter() {
      formatters = new Dictionary<Type, Formatter>{
                       {typeof (BeginToken), FormatBegin},
                       {typeof (EndToken), FormatEnd},
                       {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();      
    }

    public string Format(ISerializationToken token) {
      return formatters[token.GetType()](token);
    }

    private string Prefix {
      get { return new string(' ', depth * 2); }
    }

    private string FormatBegin(ISerializationToken token) {      
      BeginToken beginToken = (BeginToken)token;
      var attributes = new Dictionary<string, string> {{"name", beginToken.Name}};
      if ( beginToken.TypeId != null )
        attributes.Add("typeId", beginToken.TypeId.ToString());
      if ( beginToken.Id != null ) 
        attributes.Add("id", beginToken.Id.ToString());                                           
      string result = Prefix +
                      FormatNode("COMPOSITE", attributes, NodeType.Start) + "\n";
      depth += 1;
      return result;
    }

    private string FormatEnd(ISerializationToken token) {      
      depth -= 1;
      return Prefix + "</COMPOSITE>\n";
    }

    private string FormatPrimitive(ISerializationToken token) {
      PrimitiveToken dataToken = (PrimitiveToken)token;
      Dictionary<string, string> attributes =
        new Dictionary<string, string> {
            {"typeId", dataToken.TypeId.ToString()}};
      if ( !string.IsNullOrEmpty(dataToken.Name) )
        attributes.Add("name", dataToken.Name);
      if ( dataToken.Id != null )
        attributes.Add("id", dataToken.Id.ToString());
      return Prefix +
        FormatNode("PRIMITIVE", attributes, NodeType.Start) +
        dataToken.SerialData + "</PRIMITIVE>\n";      
    }

    private string FormatReference(ISerializationToken token) {
      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;
      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";
    }

    public IEnumerable<string> Format(Dictionary<string, int> typeCache) {
      yield return "<TYPECACHE>";
      foreach ( var pair in typeCache ) {
        yield return String.Format("  <TYPE id=\"{0}\" name=\"{1}\"/>",
                                   pair.Value, pair.Key);        
      }
      yield return "</TYPECACHE>";
    }
  }
}