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)
   7 //
   8 // Copyright (C) Tim Coleman, 2002
   9 //
  10
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections;
  34 using System.Text;
  35 using System.Xml;
  36 using System.Globalization;
  37
  38 namespace System.Xml.Serialization {
  39         internal class XmlCustomFormatter {
  40
  41                 #region Methods
  42
  43                 internal static string FromByteArrayBase64 (byte[] value)
  44                 {
  45                         return Convert.ToBase64String(value);
  46                 }
  47
  48                 internal static string FromByteArrayHex (byte[] value)
  49                 {
  50                         if (value == null) return null;
  51                         StringBuilder output = new StringBuilder ();
  52                         foreach (byte val in value)
  53                                 output.Append (val.ToString ("X2", CultureInfo.InvariantCulture));
  54                         return output.ToString ();
  55                 }
  56
  57                 internal static string FromChar (char value)
  58                 {
  59                         return ((int) value).ToString (CultureInfo.InvariantCulture);
  60                 }
  61
  62                 internal static string FromDate (DateTime value)
  63                 {
  64                         return XmlConvert.ToString (value, "yyyy-MM-dd");
  65                 }
  66
  67                 internal static string FromDateTime (DateTime value)
  68                 {
  69                         return XmlConvert.ToString (value, "yyyy-MM-ddTHH:mm:ss.fffffffzzz");
  70                 }
  71
  72                 internal static string FromTime (DateTime value)
  73                 {
  74                         return XmlConvert.ToString (value, "HH:mm:ss.fffffffzzz");
  75                 }
  76
  77                 internal static string FromEnum (long value, string[] values, long[] ids)
  78                 {
  79                         int length = ids.Length;
  80
  81                         for (int i = 0; i < length; i ++) {
  82                                 if (ids[i] == value)
  83                                         if (i >= values.Length)
  84                                                 return String.Empty;
  85                                         else
  86                                                 return values[i].ToString ();
  87                         }
  88                         return String.Empty;
  89                 }
  90
  91                 internal static string FromXmlName (string name)
  92                 {
  93                         return XmlConvert.EncodeName (name);
  94                 }
  95
  96                 internal static string FromXmlNCName (string ncName)
  97                 {
  98                         return XmlConvert.EncodeLocalName (ncName);
  99                 }
 100
 101                 internal static string FromXmlNmToken (string nmToken)
 102                 {
 103                         return XmlConvert.EncodeNmToken (nmToken);
 104                 }
 105
 106                 internal static string FromXmlNmTokens (string nmTokens)
 107                 {
 108                         string [] tokens = nmTokens.Split (' ');
 109                         for (int i=0; i<tokens.Length; i++)
 110                                 tokens [i] = FromXmlNmToken (tokens [i]);
 111                         return String.Join (" ", tokens);
 112                 }
 113
 114                 internal static byte[] ToByteArrayBase64 (string value)
 115                 {
 116                         return Convert.FromBase64String(value);
 117                 }
 118
 119                 internal static char ToChar (string value)
 120                 {
 121                         return (char) XmlConvert.ToUInt16 (value);
 122                 }
 123
 124                 internal static DateTime ToDate (string value)
 125                 {
 126                         return ToDateTime (value);
 127                 }
 128
 129                 internal static DateTime ToDateTime (string value)
 130                 {
 131                         return XmlConvert.ToDateTime (value);
 132                 }
 133
 134                 internal static DateTime ToTime (string value)
 135                 {
 136                         return ToDateTime (value);
 137                 }
 138
 139                 internal static long ToEnum (string value, Hashtable values, string typeName, bool validate)
 140                 {
 141                         // Assuming that h contains map from value to Enumerated Name
 142 /*
 143                         You can try :
 144                                 return ToEnum ("Element", h, "XmlNodeType");
 145                         where:
 146                                 (1) no keys and values for h.
 147                                 (2) string keys and Enum, Type, long, string value.
 148 */
 149                         string memberName = (string) values [value];
 150                         if (memberName == null)
 151                                 throw new InvalidOperationException (String.Format ("{0} is not a valid member of type {1}", value, typeName));
 152
 153                         return (long) Enum.Parse (Type.GetType (typeName), memberName);
 154                 }
 155
 156                 internal static string ToXmlName (string value)
 157                 {
 158                         return XmlConvert.DecodeName (value);
 159                 }
 160
 161                 internal static string ToXmlNCName (string value)
 162                 {
 163                         return ToXmlName (value);
 164                 }
 165
 166                 internal static string ToXmlNmToken (string value)
 167                 {
 168                         return ToXmlName (value);
 169                 }
 170
 171                 internal static string ToXmlNmTokens (string value)
 172                 {
 173                         return ToXmlName (value);
 174                 }
 175
 176                 internal static string ToXmlString (TypeData type, object value)
 177                 {
 178                         if (value == null) return null;
 179                         switch (type.XmlType)
 180                         {
 181                                 case "boolean": return XmlConvert.ToString ((bool)value);
 182                                 case "unsignedByte": return XmlConvert.ToString ((byte)value);
 183                                 case "char": return XmlConvert.ToString ((int)(char)value);
 184                                 case "dateTime": return XmlConvert.ToString ((DateTime)value);
 185                                 case "date": return ((DateTime)value).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
 186                                 case "time": return ((DateTime)value).ToString("HH:mm:ss.fffffffzzz", CultureInfo.InvariantCulture);
 187                                 case "decimal": return XmlConvert.ToString ((decimal)value);
 188                                 case "double": return XmlConvert.ToString ((double)value);
 189                                 case "short": return XmlConvert.ToString ((Int16)value);
 190                                 case "int": return XmlConvert.ToString ((Int32)value);
 191                                 case "long": return XmlConvert.ToString ((Int64)value);
 192                                 case "byte": return XmlConvert.ToString ((sbyte)value);
 193                                 case "float": return XmlConvert.ToString ((Single)value);
 194                                 case "unsignedShort": return XmlConvert.ToString ((UInt16)value);
 195                                 case "unsignedInt": return XmlConvert.ToString ((UInt32)value);
 196                                 case "unsignedLong": return XmlConvert.ToString ((UInt64)value);
 197                                 case "guid": return XmlConvert.ToString ((Guid)value);
 198                                 case "base64Binary": return Convert.ToBase64String ((byte[])value);
 199                         default: return value is IFormattable ? ((IFormattable) value).ToString (null, CultureInfo.InvariantCulture) : value.ToString ();
 200                         }
 201                 }
 202
 203                 internal static object FromXmlString (TypeData type, string value)
 204                 {
 205                         if (value == null) return null;
 206
 207                         switch (type.XmlType)
 208                         {
 209                                 case "boolean": return XmlConvert.ToBoolean (value);
 210                                 case "unsignedByte": return XmlConvert.ToByte (value);
 211                                 case "char": return (char)XmlConvert.ToInt32 (value);
 212                                 case "dateTime": return XmlConvert.ToDateTime (value);
 213                                 case "date": return DateTime.ParseExact (value, "yyyy-MM-dd", null);
 214                                 case "time": return DateTime.ParseExact (value, "HH:mm:ss.fffffffzzz", null);
 215                                 case "decimal": return XmlConvert.ToDecimal (value);
 216                                 case "double": return XmlConvert.ToDouble (value);
 217                                 case "short": return XmlConvert.ToInt16 (value);
 218                                 case "int": return XmlConvert.ToInt32 (value);
 219                                 case "long": return XmlConvert.ToInt64 (value);
 220                                 case "byte": return XmlConvert.ToSByte (value);
 221                                 case "float": return XmlConvert.ToSingle (value);
 222                                 case "unsignedShort": return XmlConvert.ToUInt16 (value);
 223                                 case "unsignedInt": return XmlConvert.ToUInt32 (value);
 224                                 case "unsignedLong": return XmlConvert.ToUInt64 (value);
 225                                 case "guid": return XmlConvert.ToGuid (value);
 226                                 case "base64Binary": return Convert.FromBase64String (value);
 227                                 default:
 228                                         if (type.Type != null)
 229                                                 return Convert.ChangeType (value, type.Type);
 230                                         else
 231                                                 return value;
 232                         }
 233                 }
 234
 235                 internal static string GenerateToXmlString (TypeData type, string value)
 236                 {
 237                         switch (type.XmlType)
 238                         {
 239                                 case "boolean": return "(" + value + "?\"true\":\"false\")";
 240                                 case "unsignedByte": return value + ".ToString(CultureInfo.InvariantCulture)";
 241                                 case "char": return "((int)(" + value + ")).ToString(CultureInfo.InvariantCulture)";
 242                                 case "dateTime": return value + ".ToString(\"yyyy-MM-ddTHH:mm:ss.fffffffzzz\", CultureInfo.InvariantCulture)";
 243                                 case "date": return value + ".ToString(\"yyyy-MM-dd\", CultureInfo.InvariantCulture)";
 244                                 case "time": return value + ".ToString(\"HH:mm:ss.fffffffzzz\", CultureInfo.InvariantCulture)";
 245                                 case "decimal": return "XmlConvert.ToString (" + value + ")";
 246                                 case "double": return "XmlConvert.ToString (" + value + ")";
 247                                 case "short": return value + ".ToString(CultureInfo.InvariantCulture)";
 248                                 case "int": return value + ".ToString(CultureInfo.InvariantCulture)";
 249                                 case "long": return value + ".ToString(CultureInfo.InvariantCulture)";
 250                                 case "byte": return value + ".ToString(CultureInfo.InvariantCulture)";
 251                                 case "float": return "XmlConvert.ToString (" + value + ")";
 252                                 case "unsignedShort": return value + ".ToString(CultureInfo.InvariantCulture)";
 253                                 case "unsignedInt": return value + ".ToString(CultureInfo.InvariantCulture)";
 254                                 case "unsignedLong": return value + ".ToString(CultureInfo.InvariantCulture)";
 255                                 case "guid": return "XmlConvert.ToString (" + value + ")";
 256                                 case "base64Binary": return "Convert.ToBase64String (" + value + ")";
 257                                 case "NMTOKEN":
 258                                 case "Name":
 259                                 case "NCName":
 260                                 case "language":
 261                                 case "ENTITY":
 262                                 case "ID":
 263                                 case "IDREF":
 264                                 case "NOTATION":
 265                                 case "token":
 266                                 case "normalizedString":
 267                                 case "string": return value;
 268                                 default: return "((" + value + " != null) ? (" + value + ").ToString() : null)";
 269                         }
 270                 }
 271
 272                 internal static string GenerateFromXmlString (TypeData type, string value)
 273                 {
 274                         switch (type.XmlType)
 275                         {
 276                                 case "boolean": return "XmlConvert.ToBoolean (" + value + ")";
 277                                 case "unsignedByte": return "byte.Parse (" + value + ", CultureInfo.InvariantCulture)";
 278                                 case "char": return "(char)Int32.Parse (" + value + ", CultureInfo.InvariantCulture)";
 279                                 case "dateTime": return "XmlConvert.ToDateTime (" + value + ")";
 280                                 case "date": return "DateTime.ParseExact (" + value + ", \"yyyy-MM-dd\", CultureInfo.InvariantCulture)";
 281                                 case "time": return "DateTime.ParseExact (" + value + ", \"HH:mm:ss.fffffffzzz\", CultureInfo.InvariantCulture)";
 282                                 case "decimal": return "Decimal.Parse (" + value + ", CultureInfo.InvariantCulture)";
 283                                 case "double": return "XmlConvert.ToDouble (" + value + ")";
 284                                 case "short": return "Int16.Parse (" + value + ", CultureInfo.InvariantCulture)";
 285                                 case "int": return "Int32.Parse (" + value + ", CultureInfo.InvariantCulture)";
 286                                 case "long": return "Int64.Parse (" + value + ", CultureInfo.InvariantCulture)";
 287                                 case "byte": return "SByte.Parse (" + value + ", CultureInfo.InvariantCulture)";
 288                                 case "float": return "XmlConvert.ToSingle (" + value + ", CultureInfo.InvariantCulture)";
 289                                 case "unsignedShort": return "UInt16.Parse (" + value + ", CultureInfo.InvariantCulture)";
 290                                 case "unsignedInt": return "UInt32.Parse (" + value + ", CultureInfo.InvariantCulture)";
 291                                 case "unsignedLong": return "UInt64.Parse (" + value + ", CultureInfo.InvariantCulture)";
 292                                 case "guid": return "XmlConvert.ToGuid (" + value + ")";
 293                                 case "base64Binary": return "Convert.FromBase64String (" + value + ")";
 294                                 default: return value;
 295                         }
 296                 }
 297
 298                 #endregion // Methods
 299         }
 300 }