mcs/class/System.XML/System.Xml.Serialization/XmlCustomFormatter.cs

   1 //
   2 // System.Xml.Serialization.XmlCustomFormatter.cs
   3 //
   4 // Author:
   5 //   Tim Coleman (tim@timcoleman.com)
   6 //   Lluis Sanchez Gual (lluis@ximian.com)\r
   7 //
   8 // Copyright (C) Tim Coleman, 2002
   9 //
  10
  11 using System;
  12 using System.Collections;
  13 using System.Text;
  14 using System.Xml;
  15 using System.Globalization;
  16
  17 namespace System.Xml.Serialization {
  18         internal class XmlCustomFormatter {
  19
  20                 #region Methods
  21
  22                 internal static string FromByteArrayBase64 (byte[] value)
  23                 {
  24                         return Convert.ToBase64String(value);
  25                 }
  26
  27                 internal static string FromByteArrayHex (byte[] value)
  28                 {
  29                         if (value == null) return null;
  30                         StringBuilder output = new StringBuilder ();
  31                         foreach (byte val in value)
  32                                 output.Append (val.ToString ("X2"));
  33                         return output.ToString ();
  34                 }
  35
  36                 internal static string FromChar (char value)
  37                 {
  38                         return ((int) value).ToString ();
  39                 }
  40
  41                 internal static string FromDate (DateTime value)
  42                 {
  43                         return XmlConvert.ToString (value, "yyyy-MM-dd");
  44                 }
  45
  46                 internal static string FromDateTime (DateTime value)
  47                 {
  48                         return XmlConvert.ToString (value, "yyyy-MM-ddTHH:mm:ss.fffffffzzz");
  49                 }
  50
  51                 internal static string FromTime (DateTime value)
  52                 {
  53                         return XmlConvert.ToString (value, "HH:mm:ss.fffffffzzz");
  54                 }
  55
  56                 internal static string FromEnum (long value, string[] values, long[] ids)
  57                 {
  58                         int length = ids.Length;
  59
  60                         for (int i = 0; i < length; i ++) {
  61                                 if (ids[i] == value)
  62                                         if (i >= values.Length)
  63                                                 return String.Empty;
  64                                         else
  65                                                 return values[i].ToString ();
  66                         }
  67                         return String.Empty;
  68                 }
  69
  70                 internal static string FromXmlName (string name)
  71                 {
  72                         return XmlConvert.EncodeName (name);
  73                 }
  74
  75                 internal static string FromXmlNCName (string ncName)
  76                 {
  77                         return XmlConvert.EncodeLocalName (ncName);
  78                 }
  79
  80                 internal static string FromXmlNmToken (string nmToken)
  81                 {
  82                         return XmlConvert.EncodeNmToken (nmToken);
  83                 }
  84
  85                 internal static string FromXmlNmTokens (string nmTokens)
  86                 {
  87                         string [] tokens = nmTokens.Split (' ');
  88                         for (int i=0; i<tokens.Length; i++)
  89                                 tokens [i] = FromXmlNmToken (tokens [i]);
  90                         return String.Join (" ", tokens);
  91                 }
  92
  93                 internal static byte[] ToByteArrayBase64 (string value)
  94                 {
  95                         return Convert.FromBase64String(value);
  96                 }
  97
  98                 internal static char ToChar (string value)
  99                 {
 100                         return (char) XmlConvert.ToUInt16 (value);
 101                 }
 102
 103                 internal static DateTime ToDate (string value)
 104                 {
 105                         return ToDateTime (value);
 106                 }
 107
 108                 internal static DateTime ToDateTime (string value)
 109                 {
 110                         return XmlConvert.ToDateTime (value);
 111                 }
 112
 113                 internal static DateTime ToTime (string value)
 114                 {
 115                         return ToDateTime (value);
 116                 }
 117
 118                 internal static long ToEnum (string value, Hashtable values, string typeName, bool validate)
 119                 {
 120                         // Assuming that h contains map from value to Enumerated Name
 121 /*
 122                         You can try :
 123                                 return ToEnum ("Element", h, "XmlNodeType");
 124                         where:
 125                                 (1) no keys and values for h.
 126                                 (2) string keys and Enum, Type, long, string value.
 127 */
 128                         string memberName = (string) values [value];
 129                         if (memberName == null)
 130                                 throw new InvalidOperationException (String.Format ("{0} is not a valid member of type {1}", value, typeName));
 131
 132                         return (long) Enum.Parse (Type.GetType (typeName), memberName);
 133                 }
 134
 135                 internal static string ToXmlName (string value)
 136                 {
 137                         return XmlConvert.DecodeName (value);
 138                 }
 139
 140                 internal static string ToXmlNCName (string value)
 141                 {
 142                         return ToXmlName (value);
 143                 }
 144
 145                 internal static string ToXmlNmToken (string value)
 146                 {
 147                         return ToXmlName (value);
 148                 }
 149
 150                 internal static string ToXmlNmTokens (string value)
 151                 {
 152                         return ToXmlName (value);
 153                 }
 154
 155                 internal static string ToXmlString (TypeData type, object value)
 156                 {
 157                         if (value == null) return null;
 158                         switch (type.XmlType)
 159                         {
 160                                 case "boolean": return XmlConvert.ToString ((bool)value);
 161                                 case "unsignedByte": return XmlConvert.ToString ((byte)value);
 162                                 case "char": return XmlConvert.ToString ((int)(char)value);
 163                                 case "dateTime": return XmlConvert.ToString ((DateTime)value);
 164                                 case "date": return ((DateTime)value).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
 165                                 case "time": return ((DateTime)value).ToString("HH:mm:ss.fffffffzzz", CultureInfo.InvariantCulture);
 166                                 case "decimal": return XmlConvert.ToString ((decimal)value);
 167                                 case "double": return XmlConvert.ToString ((double)value);
 168                                 case "short": return XmlConvert.ToString ((Int16)value);
 169                                 case "int": return XmlConvert.ToString ((Int32)value);
 170                                 case "long": return XmlConvert.ToString ((Int64)value);
 171                                 case "byte": return XmlConvert.ToString ((sbyte)value);
 172                                 case "float": return XmlConvert.ToString ((Single)value);
 173                                 case "unsignedShort": return XmlConvert.ToString ((UInt16)value);
 174                                 case "unsignedInt": return XmlConvert.ToString ((UInt32)value);
 175                                 case "unsignedLong": return XmlConvert.ToString ((UInt64)value);
 176                                 case "guid": return XmlConvert.ToString ((Guid)value);
 177                                 case "base64Binary": return Convert.ToBase64String ((byte[])value);
 178                                 case "anyURI":
 179                                 default: return value.ToString ();
 180                         }
 181                 }
 182
 183                 internal static object FromXmlString (TypeData type, string value)
 184                 {
 185                         if (value == null) return null;
 186
 187                         switch (type.XmlType)
 188                         {
 189                                 case "boolean": return XmlConvert.ToBoolean (value);
 190                                 case "unsignedByte": return XmlConvert.ToByte (value);
 191                                 case "char": return (char)XmlConvert.ToInt32 (value);
 192                                 case "dateTime": return XmlConvert.ToDateTime (value);
 193                                 case "date": return DateTime.ParseExact (value, "yyyy-MM-dd", null);
 194                                 case "time": return DateTime.ParseExact (value, "HH:mm:ss.fffffffzzz", null);
 195                                 case "decimal": return XmlConvert.ToDecimal (value);
 196                                 case "double": return XmlConvert.ToDouble (value);
 197                                 case "short": return XmlConvert.ToInt16 (value);
 198                                 case "int": return XmlConvert.ToInt32 (value);
 199                                 case "long": return XmlConvert.ToInt64 (value);
 200                                 case "byte": return XmlConvert.ToSByte (value);
 201                                 case "float": return XmlConvert.ToSingle (value);
 202                                 case "unsignedShort": return XmlConvert.ToUInt16 (value);
 203                                 case "unsignedInt": return XmlConvert.ToUInt32 (value);
 204                                 case "unsignedLong": return XmlConvert.ToUInt64 (value);
 205                                 case "guid": return XmlConvert.ToGuid (value);
 206                                 case "base64Binary": return Convert.FromBase64String (value);
 207                                 case "anyUri": return new Uri (value);
 208                                 default:
 209                                         if (type.Type != null)
 210                                                 return Convert.ChangeType (value, type.Type);
 211                                         else
 212                                                 return value;
 213                         }
 214                 }
 215
 216                 internal static string GenerateToXmlString (TypeData type, string value)
 217                 {
 218                         switch (type.XmlType)
 219                         {
 220                                 case "boolean": return "(" + value + "?\"true\":\"false\")";
 221                                 case "unsignedByte": return value + ".ToString()";
 222                                 case "char": return value + ".ToString()";
 223                                 case "dateTime": return value + ".ToString(\"yyyy-MM-ddTHH:mm:ss.fffffffzzz\", CultureInfo.InvariantCulture)";
 224                                 case "date": return value + ".ToString(\"yyyy-MM-dd\", CultureInfo.InvariantCulture)";
 225                                 case "time": return value + ".ToString(\"HH:mm:ss.fffffffzzz\", CultureInfo.InvariantCulture";
 226                                 case "decimal": return "XmlConvert.ToString (" + value + ")";
 227                                 case "double": return "XmlConvert.ToString (" + value + ")";
 228                                 case "short": return value + ".ToString()";
 229                                 case "int": return value + ".ToString()";
 230                                 case "long": return value + ".ToString()";
 231                                 case "byte": return value + ".ToString()";
 232                                 case "float": return "XmlConvert.ToString (" + value + ")";
 233                                 case "unsignedShort": return value + ".ToString()";
 234                                 case "unsignedInt": return value + ".ToString()";
 235                                 case "unsignedLong": return value + ".ToString()";
 236                                 case "guid": return "XmlConvert.ToString (" + value + ")";
 237                                 case "base64Binary": return "Convert.ToBase64String (" + value + ")";
 238                                 case "NMTOKEN":
 239                                 case "Name":
 240                                 case "NCName":
 241                                 case "language":
 242                                 case "ENTITY":
 243                                 case "ID":
 244                                 case "IDREF":
 245                                 case "NOTATION":
 246                                 case "token":
 247                                 case "normalizedString":
 248                                 case "string": return value;
 249                                 default: return "((" + value + " != null) ? (" + value + ").ToString() : null)";
 250                         }
 251                 }
 252
 253                 internal static string GenerateFromXmlString (TypeData type, string value)
 254                 {
 255                         switch (type.XmlType)
 256                         {
 257                                 case "boolean": return "XmlConvert.ToBoolean (" + value + ")";
 258                                 case "unsignedByte": return "SByte.Parse(" + value + ")";
 259                                 case "char": return "(char)Int32.Parse (" + value + ")";
 260                                 case "dateTime": return "XmlConvert.ToDateTime (" + value + ")";
 261                                 case "date": return "DateTime.ParseExact (" + value + ", \"yyyy-MM-dd\", null)";
 262                                 case "time": return "DateTime.ParseExact (" + value + ", \"HH:mm:ss.fffffffzzz\", null)";
 263                                 case "decimal": return "Decimal.Parse (" + value + ")";
 264                                 case "double": return "XmlConvert.ToDouble (" + value + ")";
 265                                 case "short": return "Int16.Parse (" + value + ")";
 266                                 case "int": return "Int32.Parse (" + value + ")";
 267                                 case "long": return "Int64.Parse (" + value + ")";
 268                                 case "byte": return "SByte.Parse (" + value + ")";
 269                                 case "float": return "XmlConvert.ToSingle (" + value + ")";
 270                                 case "unsignedShort": return "UInt16.Parse (" + value + ")";
 271                                 case "unsignedInt": return "UInt32.Parse (" + value + ")";
 272                                 case "unsignedLong": return "UInt64.Parse (" + value + ")";
 273                                 case "guid": return "XmlConvert.ToGuid (" + value + ")";
 274                                 case "base64Binary": return "Convert.FromBase64String (" + value + ")";
 275                                 default: return value;
 276                         }
 277                 }
 278
 279                 #endregion // Methods
 280         }
 281 }