mcs/class/corlib/System/Variant.cs

   1 //
   2 // System.Variant
   3 //
   4 // Authors:
   5 //   Jonathan Chambers <jonathan.chambers@ansys.com>
   6 //
   7 // Copyright (C) 2006 Novell (http://www.novell.com)
   8 //
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System.Runtime.InteropServices;
  31
  32 namespace System
  33 {
  34         [StructLayout(LayoutKind.Explicit)]
  35         internal unsafe struct Variant
  36         {
  37                 [FieldOffset(0)]
  38                 public short vt;
  39
  40                 [FieldOffset(2)]
  41                 public ushort wReserved1;
  42
  43                 [FieldOffset(4)]
  44                 public ushort wReserved2;
  45
  46                 [FieldOffset(6)]
  47                 public ushort wReserved3;
  48
  49                 [FieldOffset(8)]
  50                 public long llVal;
  51
  52                 [FieldOffset(8)]
  53                 public int lVal;
  54
  55                 [FieldOffset(8)]
  56                 public byte bVal;
  57
  58                 [FieldOffset(8)]
  59                 public short iVal;
  60
  61                 [FieldOffset(8)]
  62                 public float fltVal;
  63
  64                 [FieldOffset(8)]
  65                 public double dblVal;
  66
  67                 [FieldOffset(8)]
  68                 public short boolVal;
  69
  70                 [FieldOffset(8)]
  71                 public IntPtr bstrVal;
  72
  73                 [FieldOffset(8)]
  74                 public sbyte cVal;
  75
  76                 [FieldOffset(8)]
  77                 public ushort uiVal;
  78
  79                 [FieldOffset(8)]
  80                 public uint ulVal;
  81
  82                 [FieldOffset(8)]
  83                 public ulong ullVal;
  84
  85                 [FieldOffset(8)]
  86                 public int intVal;
  87
  88                 [FieldOffset(8)]
  89                 public uint uintVal;
  90
  91                 [FieldOffset(8)]
  92                 public IntPtr pdispVal;
  93
  94                 [FieldOffset(8)]
  95                 public BRECORD bRecord;
  96
  97                 public void SetValue(object obj) {
  98                         vt = (short)VarEnum.VT_EMPTY;
  99                         if (obj == null)
 100                                 return;
 101
 102                         Type t = obj.GetType();
 103                         if (t.IsEnum)
 104                                 t = Enum.GetUnderlyingType (t);
 105
 106                         if (t == typeof(sbyte))
 107                         {
 108                                 vt = (short)VarEnum.VT_I1;
 109                                 cVal = (sbyte)obj;
 110                         }
 111                         else if (t == typeof(byte))
 112                         {
 113                                 vt = (short)VarEnum.VT_UI1;
 114                                 bVal = (byte)obj;
 115                         }
 116                         else if (t == typeof(short))
 117                         {
 118                                 vt = (short)VarEnum.VT_I2;
 119                                 iVal = (short)obj;
 120                         }
 121                         else if (t == typeof(ushort))
 122                         {
 123                                 vt = (short)VarEnum.VT_UI2;
 124                                 uiVal = (ushort)obj;
 125                         }
 126                         else if (t == typeof(int))
 127                         {
 128                                 vt = (short)VarEnum.VT_I4;
 129                                 lVal = (int)obj;
 130                         }
 131                         else if (t == typeof(uint))
 132                         {
 133                                 vt = (short)VarEnum.VT_UI4;
 134                                 ulVal = (uint)obj;
 135                         }
 136                         else if (t == typeof(long))
 137                         {
 138                                 vt = (short)VarEnum.VT_I8;
 139                                 llVal = (long)obj;
 140                         }
 141                         else if (t == typeof(ulong))
 142                         {
 143                                 vt = (short)VarEnum.VT_UI8;
 144                                 ullVal = (ulong)obj;
 145                         }
 146                         else if (t == typeof(float))
 147                         {
 148                                 vt = (short)VarEnum.VT_R4;
 149                                 fltVal = (float)obj;
 150                         }
 151                         else if (t == typeof(double))
 152                         {
 153                                 vt = (short)VarEnum.VT_R8;
 154                                 dblVal = (double)obj;
 155                         }
 156                         else if (t == typeof(string))
 157                         {
 158                                 vt = (short)VarEnum.VT_BSTR;
 159                                 bstrVal = Marshal.StringToBSTR((string)obj);
 160                         }
 161                         else if (t == typeof(bool))
 162                         {
 163                                 vt = (short)VarEnum.VT_BOOL;
 164                                 lVal = ((bool)obj) ? -1 : 0;
 165                         }
 166                         else if (t == typeof (BStrWrapper))
 167                         {
 168                                 vt = (short)VarEnum.VT_BSTR;
 169                                 bstrVal = Marshal.StringToBSTR(((BStrWrapper)obj).WrappedObject);
 170                         }
 171 #if FEATURE_COMINTEROP
 172                         else if (t == typeof (UnknownWrapper))
 173                         {
 174                                 vt = (short)VarEnum.VT_UNKNOWN;
 175                                 pdispVal = Marshal.GetIUnknownForObject(((UnknownWrapper)obj).WrappedObject);
 176                         }
 177                         else if (t == typeof (DispatchWrapper))
 178                         {
 179                                 vt = (short)VarEnum.VT_DISPATCH;
 180                                 pdispVal = Marshal.GetIDispatchForObject(((DispatchWrapper)obj).WrappedObject);
 181                         }
 182 #endif
 183                         else
 184                         {
 185 #if !FEATURE_COMINTEROP
 186                                 throw new NotImplementedException(string.Format("Variant couldn't handle object of type {0}", obj.GetType()));
 187 #else
 188                                 try
 189                                 {
 190                                         pdispVal = Marshal.GetIDispatchForObject(obj);
 191                                         vt = (short)VarEnum.VT_DISPATCH;
 192                                         return;
 193                                 }
 194                                 catch { }
 195                                 try
 196                                 {
 197                                         vt = (short)VarEnum.VT_UNKNOWN;
 198                                         pdispVal = Marshal.GetIUnknownForObject(obj);
 199                                 }
 200                                 catch (Exception ex)
 201                                 {
 202                                         throw new NotImplementedException(string.Format("Variant couldn't handle object of type {0}", obj.GetType()), ex);
 203                                 }
 204 #endif
 205                         }
 206                 }
 207
 208                 public static object GetValueAt(int vt, IntPtr addr)
 209                 {
 210                         object obj = null;
 211                         switch ((VarEnum)vt)
 212                         {
 213                         case VarEnum.VT_I1:
 214                                 obj = (sbyte)Marshal.ReadByte(addr);
 215                                 break;
 216                         case VarEnum.VT_UI1:
 217                                 obj = Marshal.ReadByte(addr);
 218                                 break;
 219                         case VarEnum.VT_I2:
 220                                 obj = Marshal.ReadInt16(addr);
 221                                 break;
 222                         case VarEnum.VT_UI2:
 223                                 obj = (ushort)Marshal.ReadInt16(addr);
 224                                 break;
 225                         case VarEnum.VT_I4:
 226                                 obj = Marshal.ReadInt32(addr);
 227                                 break;
 228                         case VarEnum.VT_UI4:
 229                                 obj = (uint)Marshal.ReadInt32(addr);
 230                                 break;
 231                         case VarEnum.VT_I8:
 232                                 obj = Marshal.ReadInt64(addr);
 233                                 break;
 234                         case VarEnum.VT_UI8:
 235                                 obj = (ulong)Marshal.ReadInt64(addr);
 236                                 break;
 237                         case VarEnum.VT_R4:
 238                                 obj = Marshal.PtrToStructure(addr, typeof(float));
 239                                 break;
 240                         case VarEnum.VT_R8:
 241                                 obj = Marshal.PtrToStructure(addr, typeof(double));
 242                                 break;
 243                         case VarEnum.VT_BOOL:
 244                                 obj = !(Marshal.ReadInt16(addr) == 0);
 245                                 break;
 246                         case VarEnum.VT_BSTR:
 247                                 obj = Marshal.PtrToStringBSTR(Marshal.ReadIntPtr(addr));
 248                                 break;
 249 // GetObjectForIUnknown is excluded from Marshal using FULL_AOT_RUNTIME
 250 #if !DISABLE_COM
 251                         case VarEnum.VT_UNKNOWN:
 252                         case VarEnum.VT_DISPATCH:
 253                         {
 254                                 IntPtr ifaceaddr = Marshal.ReadIntPtr(addr);
 255                                 if (ifaceaddr != IntPtr.Zero)
 256                                         obj = Marshal.GetObjectForIUnknown(ifaceaddr);
 257                                 break;
 258                         }
 259 #endif
 260                         }
 261                         return obj;
 262                 }
 263
 264                 public object GetValue() {
 265                         object obj = null;
 266                         switch ((VarEnum)vt)
 267                         {
 268                         case VarEnum.VT_I1:
 269                         obj = cVal;
 270                         break;
 271                         case VarEnum.VT_UI1:
 272                                 obj = bVal;
 273                                 break;
 274                         case VarEnum.VT_I2:
 275                                 obj = iVal;
 276                                 break;
 277                         case VarEnum.VT_UI2:
 278                                 obj = uiVal;
 279                                 break;
 280                         case VarEnum.VT_I4:
 281                                 obj = lVal;
 282                                 break;
 283                         case VarEnum.VT_UI4:
 284                                 obj = ulVal;
 285                                 break;
 286                         case VarEnum.VT_I8:
 287                                 obj = llVal;
 288                                 break;
 289                         case VarEnum.VT_UI8:
 290                                 obj = ullVal;
 291                                 break;
 292                         case VarEnum.VT_R4:
 293                                 obj = fltVal;
 294                                 break;
 295                         case VarEnum.VT_R8:
 296                                 obj = dblVal;
 297                                 break;
 298                         case VarEnum.VT_BOOL:
 299                                 obj = !(boolVal == 0);
 300                                 break;
 301                         case VarEnum.VT_BSTR:
 302                                 obj = Marshal.PtrToStringBSTR(bstrVal);
 303                                 break;
 304 #if FEATURE_COMINTEROP
 305                         case VarEnum.VT_UNKNOWN:
 306                         case VarEnum.VT_DISPATCH:
 307                                 if (pdispVal != IntPtr.Zero)
 308                                         obj = Marshal.GetObjectForIUnknown(pdispVal);
 309                                 break;
 310 #endif
 311                         default:
 312                                 if (((VarEnum)vt & VarEnum.VT_BYREF) == VarEnum.VT_BYREF &&
 313                                         pdispVal != IntPtr.Zero)
 314                                 {
 315                                         obj = GetValueAt(vt & ~(short)VarEnum.VT_BYREF, pdispVal);
 316                                 }
 317                                 break;
 318                         }
 319                         return obj;
 320                 }
 321
 322                 public void Clear ()
 323                 {
 324                         if ((VarEnum)vt == VarEnum.VT_BSTR) {
 325                                 Marshal.FreeBSTR (bstrVal);
 326                         }
 327 #if !DISABLE_COM
 328                         else if ((VarEnum)vt == VarEnum.VT_DISPATCH || (VarEnum)vt == VarEnum.VT_UNKNOWN) {
 329                                 if (pdispVal != IntPtr.Zero)
 330                                         Marshal.Release (pdispVal);
 331                         }
 332 #endif
 333                 }
 334         }
 335
 336         [StructLayout(LayoutKind.Sequential)]
 337         internal unsafe struct BRECORD
 338         {
 339         #pragma warning disable 169
 340                 IntPtr pvRecord;
 341                 IntPtr pRecInfo;
 342         #pragma warning restore 169
 343         }
 344 }