The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ XmlCustomFormatter

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlCustomFormatter.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.    
  19.     using System;
  20.     using System.Xml;
  21.     using System.Globalization;
  22.     using System.ComponentModel;
  23.     using System.Diagnostics;
  24.     using System.Text;
  25.     using System.Collections;
  26.     using System.Configuration;
  27.     using System.Xml.Serialization.Configuration;
  28.    
  29.     /// <summary>
  30.     /// The <see cref="XmlCustomFormatter"/> class provides a set of static methods for converting
  31.     /// primitive type values to and from their XML string representations.</summary>
  32.     internal class XmlCustomFormatter
  33.     {
  34.         private static DateTimeSerializationSection.DateTimeSerializationMode mode;
  35.        
  36.         static DateTimeSerializationSection.DateTimeSerializationMode Mode {
  37.             get {
  38.                 if (mode == DateTimeSerializationSection.DateTimeSerializationMode.Default) {
  39.                     DateTimeSerializationSection section = PrivilegedConfigurationManager.GetSection(ConfigurationStrings.DateTimeSerializationSectionPath) as DateTimeSerializationSection;
  40.                     if (section != null) {
  41.                         mode = section.Mode;
  42.                     }
  43.                     else {
  44.                         mode = DateTimeSerializationSection.DateTimeSerializationMode.Roundtrip;
  45.                     }
  46.                 }
  47.                 return mode;
  48.             }
  49.         }
  50.         private XmlCustomFormatter()
  51.         {
  52.         }
  53.         static internal string FromDefaultValue(object value, string formatter)
  54.         {
  55.             if (value == null)
  56.                 return null;
  57.             Type type = value.GetType();
  58.             if (type == typeof(DateTime)) {
  59.                 if (formatter == "DateTime") {
  60.                     return FromDateTime((DateTime)value);
  61.                 }
  62.                 if (formatter == "Date") {
  63.                     return FromDate((DateTime)value);
  64.                 }
  65.                 if (formatter == "Time") {
  66.                     return FromTime((DateTime)value);
  67.                 }
  68.             }
  69.             else if (type == typeof(string)) {
  70.                 if (formatter == "XmlName") {
  71.                     return FromXmlName((string)value);
  72.                 }
  73.                 if (formatter == "XmlNCName") {
  74.                     return FromXmlNCName((string)value);
  75.                 }
  76.                 if (formatter == "XmlNmToken") {
  77.                     return FromXmlNmToken((string)value);
  78.                 }
  79.                 if (formatter == "XmlNmTokens") {
  80.                     return FromXmlNmTokens((string)value);
  81.                 }
  82.             }
  83.             throw new Exception(Res.GetString(Res.XmlUnsupportedDefaultType, type.FullName));
  84.         }
  85.        
  86.         static internal string FromDate(DateTime value)
  87.         {
  88.             return XmlConvert.ToString(value, "yyyy-MM-dd");
  89.         }
  90.        
  91.         static internal string FromTime(DateTime value)
  92.         {
  93.             return XmlConvert.ToString(DateTime.MinValue + value.TimeOfDay, "HH:mm:ss.fffffffzzzzzz");
  94.         }
  95.        
  96.         static internal string FromDateTime(DateTime value)
  97.         {
  98.             if (Mode == DateTimeSerializationSection.DateTimeSerializationMode.Local) {
  99.                 return XmlConvert.ToString(value, "yyyy-MM-ddTHH:mm:ss.fffffffzzzzzz");
  100.             }
  101.             else {
  102.                 // for mode DateTimeSerializationMode.Roundtrip and DateTimeSerializationMode.Default
  103.                 return XmlConvert.ToString(value, XmlDateTimeSerializationMode.RoundtripKind);
  104.             }
  105.         }
  106.        
  107.         static internal string FromChar(char value)
  108.         {
  109.             return XmlConvert.ToString((UInt16)value);
  110.         }
  111.        
  112.         static internal string FromXmlName(string name)
  113.         {
  114.             return XmlConvert.EncodeName(name);
  115.         }
  116.        
  117.         static internal string FromXmlNCName(string ncName)
  118.         {
  119.             return XmlConvert.EncodeLocalName(ncName);
  120.         }
  121.        
  122.         static internal string FromXmlNmToken(string nmToken)
  123.         {
  124.             return XmlConvert.EncodeNmToken(nmToken);
  125.         }
  126.        
  127.         static internal string FromXmlNmTokens(string nmTokens)
  128.         {
  129.             if (nmTokens == null)
  130.                 return null;
  131.             if (nmTokens.IndexOf(' ') < 0)
  132.                 return FromXmlNmToken(nmTokens);
  133.             else {
  134.                 string[] toks = nmTokens.Split(new char[] {' '});
  135.                 StringBuilder sb = new StringBuilder();
  136.                 for (int i = 0; i < toks.Length; i++) {
  137.                     if (i > 0)
  138.                         sb.Append(' ');
  139.                     sb.Append(FromXmlNmToken(toks[i]));
  140.                 }
  141.                 return sb.ToString();
  142.             }
  143.         }
  144.        
  145.         static internal void WriteArrayBase64(XmlWriter writer, byte[] inData, int start, int count)
  146.         {
  147.             if (inData == null || count == 0) {
  148.                 return;
  149.             }
  150.             writer.WriteBase64(inData, start, count);
  151.         }
  152.        
  153.         static internal string FromByteArrayHex(byte[] value)
  154.         {
  155.             if (value == null)
  156.                 return null;
  157.             if (value.Length == 0)
  158.                 return "";
  159.             return XmlConvert.ToBinHexString(value);
  160.         }
  161.        
  162.         static internal string FromEnum(long val, string[] vals, long[] ids, string typeName)
  163.         {
  164.             #if DEBUG
  165.             // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
  166.             if (ids.Length != vals.Length)
  167.                 throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Invalid enum"));
  168.             #endif
  169.            
  170.             long originalValue = val;
  171.             StringBuilder sb = new StringBuilder();
  172.             int iZero = -1;
  173.            
  174.             for (int i = 0; i < ids.Length; i++) {
  175.                 if (ids[i] == 0) {
  176.                     iZero = i;
  177.                     continue;
  178.                 }
  179.                 if (val == 0) {
  180.                     break;
  181.                 }
  182.                 if ((ids[i] & originalValue) == ids[i]) {
  183.                     if (sb.Length != 0)
  184.                         sb.Append(" ");
  185.                     sb.Append(vals[i]);
  186.                     val &= ~ids[i];
  187.                 }
  188.             }
  189.             if (val != 0) {
  190.                 // failed to parse the enum value
  191.                 throw new InvalidOperationException(Res.GetString(Res.XmlUnknownConstant, originalValue, typeName == null ? "enum" : typeName));
  192.             }
  193.             if (sb.Length == 0 && iZero >= 0) {
  194.                 sb.Append(vals[iZero]);
  195.             }
  196.             return sb.ToString();
  197.         }
  198.        
  199.         static internal object ToDefaultValue(string value, string formatter)
  200.         {
  201.             if (formatter == "DateTime") {
  202.                 return ToDateTime(value);
  203.             }
  204.             if (formatter == "Date") {
  205.                 return ToDate(value);
  206.             }
  207.             if (formatter == "Time") {
  208.                 return ToTime(value);
  209.             }
  210.             if (formatter == "XmlName") {
  211.                 return ToXmlName(value);
  212.             }
  213.             if (formatter == "XmlNCName") {
  214.                 return ToXmlNCName(value);
  215.             }
  216.             if (formatter == "XmlNmToken") {
  217.                 return ToXmlNmToken(value);
  218.             }
  219.             if (formatter == "XmlNmTokens") {
  220.                 return ToXmlNmTokens(value);
  221.             }
  222.             throw new Exception(Res.GetString(Res.XmlUnsupportedDefaultValue, formatter));
  223.             // Debug.WriteLineIf(CompModSwitches.XmlSerialization.TraceVerbose, "XmlSerialization::Unhandled default value " + value + " formatter " + formatter);
  224.             // return DBNull.Value;
  225.         }
  226.        
  227.         static string[] allDateTimeFormats = new string[] {"yyyy-MM-ddTHH:mm:ss.fffffffzzzzzz", "yyyy", "---dd", "---ddZ", "---ddzzzzzz", "--MM-dd", "--MM-ddZ", "--MM-ddzzzzzz", "--MM--", "--MM--Z",
  228.         "--MM--zzzzzz", "yyyy-MM", "yyyy-MMZ", "yyyy-MMzzzzzz", "yyyyzzzzzz", "yyyy-MM-dd", "yyyy-MM-ddZ", "yyyy-MM-ddzzzzzz", "HH:mm:ss", "HH:mm:ss.f",
  229.         "HH:mm:ss.ff", "HH:mm:ss.fff", "HH:mm:ss.ffff", "HH:mm:ss.fffff", "HH:mm:ss.ffffff", "HH:mm:ss.fffffff", "HH:mm:ssZ", "HH:mm:ss.fZ", "HH:mm:ss.ffZ", "HH:mm:ss.fffZ",
  230.         "HH:mm:ss.ffffZ", "HH:mm:ss.fffffZ", "HH:mm:ss.ffffffZ", "HH:mm:ss.fffffffZ", "HH:mm:sszzzzzz", "HH:mm:ss.fzzzzzz", "HH:mm:ss.ffzzzzzz", "HH:mm:ss.fffzzzzzz", "HH:mm:ss.ffffzzzzzz", "HH:mm:ss.fffffzzzzzz",
  231.         "HH:mm:ss.ffffffzzzzzz", "HH:mm:ss.fffffffzzzzzz", "yyyy-MM-ddTHH:mm:ss", "yyyy-MM-ddTHH:mm:ss.f", "yyyy-MM-ddTHH:mm:ss.ff", "yyyy-MM-ddTHH:mm:ss.fff", "yyyy-MM-ddTHH:mm:ss.ffff", "yyyy-MM-ddTHH:mm:ss.fffff", "yyyy-MM-ddTHH:mm:ss.ffffff", "yyyy-MM-ddTHH:mm:ss.fffffff",
  232.         "yyyy-MM-ddTHH:mm:ssZ", "yyyy-MM-ddTHH:mm:ss.fZ", "yyyy-MM-ddTHH:mm:ss.ffZ", "yyyy-MM-ddTHH:mm:ss.fffZ", "yyyy-MM-ddTHH:mm:ss.ffffZ", "yyyy-MM-ddTHH:mm:ss.fffffZ", "yyyy-MM-ddTHH:mm:ss.ffffffZ", "yyyy-MM-ddTHH:mm:ss.fffffffZ", "yyyy-MM-ddTHH:mm:sszzzzzz", "yyyy-MM-ddTHH:mm:ss.fzzzzzz",
  233.            
  234.         "yyyy-MM-ddTHH:mm:ss.ffzzzzzz", "yyyy-MM-ddTHH:mm:ss.fffzzzzzz", "yyyy-MM-ddTHH:mm:ss.ffffzzzzzz", "yyyy-MM-ddTHH:mm:ss.fffffzzzzzz", "yyyy-MM-ddTHH:mm:ss.ffffffzzzzzz"};
  235.        
  236.         static string[] allDateFormats = new string[] {"yyyy-MM-ddzzzzzz", "yyyy-MM-dd", "yyyy-MM-ddZ", "yyyy", "---dd", "---ddZ", "---ddzzzzzz", "--MM-dd", "--MM-ddZ", "--MM-ddzzzzzz",
  237.         "--MM--", "--MM--Z", "--MM--zzzzzz", "yyyy-MM", "yyyy-MMZ", "yyyy-MMzzzzzz", "yyyyzzzzzz"};
  238.        
  239.         static string[] allTimeFormats = new string[] {"HH:mm:ss.fffffffzzzzzz", "HH:mm:ss", "HH:mm:ss.f", "HH:mm:ss.ff", "HH:mm:ss.fff", "HH:mm:ss.ffff", "HH:mm:ss.fffff", "HH:mm:ss.ffffff", "HH:mm:ss.fffffff", "HH:mm:ssZ",
  240.         "HH:mm:ss.fZ", "HH:mm:ss.ffZ", "HH:mm:ss.fffZ", "HH:mm:ss.ffffZ", "HH:mm:ss.fffffZ", "HH:mm:ss.ffffffZ", "HH:mm:ss.fffffffZ", "HH:mm:sszzzzzz", "HH:mm:ss.fzzzzzz", "HH:mm:ss.ffzzzzzz",
  241.         "HH:mm:ss.fffzzzzzz", "HH:mm:ss.ffffzzzzzz", "HH:mm:ss.fffffzzzzzz", "HH:mm:ss.ffffffzzzzzz"};
  242.        
  243.         static internal DateTime ToDateTime(string value)
  244.         {
  245.             if (Mode == DateTimeSerializationSection.DateTimeSerializationMode.Local) {
  246.                 return ToDateTime(value, allDateTimeFormats);
  247.             }
  248.             else {
  249.                 // for mode DateTimeSerializationMode.Roundtrip and DateTimeSerializationMode.Default
  250.                 return XmlConvert.ToDateTime(value, XmlDateTimeSerializationMode.RoundtripKind);
  251.             }
  252.         }
  253.        
  254.         static internal DateTime ToDateTime(string value, string[] formats)
  255.         {
  256.             return XmlConvert.ToDateTime(value, formats);
  257.         }
  258.        
  259.         static internal DateTime ToDate(string value)
  260.         {
  261.             return ToDateTime(value, allDateFormats);
  262.         }
  263.        
  264.         static internal DateTime ToTime(string value)
  265.         {
  266.             return DateTime.ParseExact(value, allTimeFormats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite | DateTimeStyles.NoCurrentDateDefault);
  267.         }
  268.        
  269.         static internal char ToChar(string value)
  270.         {
  271.             return (char)XmlConvert.ToUInt16(value);
  272.         }
  273.        
  274.         static internal string ToXmlName(string value)
  275.         {
  276.             return XmlConvert.DecodeName(CollapseWhitespace(value));
  277.         }
  278.        
  279.         static internal string ToXmlNCName(string value)
  280.         {
  281.             return XmlConvert.DecodeName(CollapseWhitespace(value));
  282.         }
  283.        
  284.         static internal string ToXmlNmToken(string value)
  285.         {
  286.             return XmlConvert.DecodeName(CollapseWhitespace(value));
  287.         }
  288.        
  289.         static internal string ToXmlNmTokens(string value)
  290.         {
  291.             return XmlConvert.DecodeName(CollapseWhitespace(value));
  292.         }
  293.        
  294.         static internal byte[] ToByteArrayBase64(string value)
  295.         {
  296.             if (value == null)
  297.                 return null;
  298.             value = value.Trim();
  299.             if (value.Length == 0)
  300.                 return new byte[0];
  301.             return Convert.FromBase64String(value);
  302.         }
  303.         static internal byte[] ToByteArrayHex(string value)
  304.         {
  305.             if (value == null)
  306.                 return null;
  307.             value = value.Trim();
  308.             return XmlConvert.FromBinHexString(value);
  309.         }
  310.        
  311.         static internal long ToEnum(string val, Hashtable vals, string typeName, bool validate)
  312.         {
  313.             long value = 0;
  314.             string[] parts = val.Split(null);
  315.             for (int i = 0; i < parts.Length; i++) {
  316.                 object id = vals[parts[i]];
  317.                 if (id != null)
  318.                     value |= (long)id;
  319.                 else if (validate && parts[i].Length > 0)
  320.                     throw new InvalidOperationException(Res.GetString(Res.XmlUnknownConstant, parts[i], typeName));
  321.             }
  322.             return value;
  323.         }
  324.        
  325.         static string CollapseWhitespace(string value)
  326.         {
  327.             if (value == null)
  328.                 return null;
  329.             return value.Trim();
  330.         }
  331.     }
  332. }

Developer Fusion