dbus-sharp/Signature.cs

   1 // Copyright 2006 Alp Toker <alp@atoker.com>
   2 // This software is made available under the MIT License
   3 // See COPYING for details
   4 //
   5 using System;
   6 using System.Text;
   7 using System.Collections.Generic;
   8 using System.Reflection;
   9
  10 namespace Wv
  11 {
  12     public struct Signature
  13     {
  14         public static readonly Signature Empty
  15             = new Signature (String.Empty);
  16
  17         public static bool operator == (Signature a, Signature b)
  18         {
  19             if (a.data.Length != b.data.Length)
  20                 return false;
  21
  22             for (int i = 0 ; i != a.data.Length ; i++)
  23                 if (a.data[i] != b.data[i])
  24                     return false;
  25
  26             return true;
  27         }
  28
  29         public static bool operator != (Signature a, Signature b)
  30         {
  31             return !(a == b);
  32         }
  33
  34         public override bool Equals (object o)
  35         {
  36             if (o == null)
  37                 return false;
  38
  39             if (!(o is Signature))
  40                 return false;
  41
  42             return this == (Signature)o;
  43         }
  44
  45         public override int GetHashCode ()
  46         {
  47             return data.GetHashCode ();
  48         }
  49
  50         public static Signature operator + (Signature s1, Signature s2)
  51         {
  52             return Concat (s1, s2);
  53         }
  54
  55         //these need to be optimized
  56         public static Signature Concat (Signature s1, Signature s2)
  57         {
  58             return new Signature (s1.Value + s2.Value);
  59         }
  60
  61         public static Signature Copy (Signature sig)
  62         {
  63             return new Signature (sig.data);
  64         }
  65
  66         public Signature (string value)
  67         {
  68             this.data = Encoding.ASCII.GetBytes (value);
  69         }
  70
  71         public Signature (byte[] value)
  72         {
  73             this.data = (byte[])value.Clone ();
  74         }
  75
  76         //this will become obsolete soon
  77         internal Signature (DType value)
  78         {
  79             this.data = new byte[] {(byte)value};
  80         }
  81
  82         internal Signature (DType[] value)
  83         {
  84             this.data = new byte[value.Length];
  85
  86             for (int i = 0 ; i != value.Length ; i++)
  87                 this.data[i] = (byte)value[i];
  88         }
  89
  90         byte[] data;
  91
  92         //TODO: this should be private, but MessageWriter and Monitor still use it
  93         //[Obsolete]
  94         public byte[] GetBuffer ()
  95         {
  96             return data;
  97         }
  98
  99         internal DType this[int index]
 100         {
 101             get {
 102                 return (DType)data[index];
 103             }
 104         }
 105
 106         public int Length
 107         {
 108             get {
 109                 return data.Length;
 110             }
 111         }
 112
 113         //[Obsolete]
 114         public string Value
 115         {
 116             get {
 117                 return Encoding.ASCII.GetString (data);
 118             }
 119         }
 120
 121         public override string ToString ()
 122         {
 123             return Value;
 124         }
 125
 126         public Signature MakeArraySignature ()
 127         {
 128             return new Signature (DType.Array) + this;
 129         }
 130
 131         public static Signature MakeStruct (params Signature[] elems)
 132         {
 133             Signature sig = Signature.Empty;
 134
 135             sig += new Signature (DType.StructBegin);
 136
 137             foreach (Signature elem in elems)
 138                 sig += elem;
 139
 140             sig += new Signature (DType.StructEnd);
 141
 142             return sig;
 143         }
 144
 145         public static Signature MakeDictEntry (Signature keyType, Signature valueType)
 146         {
 147             Signature sig = Signature.Empty;
 148
 149             sig += new Signature (DType.DictEntryBegin);
 150
 151             sig += keyType;
 152             sig += valueType;
 153
 154             sig += new Signature (DType.DictEntryEnd);
 155
 156             return sig;
 157         }
 158
 159         public static Signature MakeDict (Signature keyType, Signature valueType)
 160         {
 161             return MakeDictEntry (keyType, valueType).MakeArraySignature ();
 162         }
 163
 164         public bool IsDict
 165         {
 166             get {
 167                 if (Length < 3)
 168                     return false;
 169
 170                 if (!IsArray)
 171                     return false;
 172
 173                 if (this[2] != DType.DictEntryBegin)
 174                     return false;
 175
 176                 return true;
 177             }
 178         }
 179
 180         public bool IsArray
 181         {
 182             get {
 183                 if (Length < 2)
 184                     return false;
 185
 186                 if (this[0] != DType.Array)
 187                     return false;
 188
 189                 return true;
 190             }
 191         }
 192
 193         public Signature GetElementSignature ()
 194         {
 195             if (!IsArray)
 196                 throw new Exception ("Cannot get the element signature of a non-array (signature was '" + this + "')");
 197
 198             //TODO: improve this
 199             if (Length != 2)
 200                 throw new NotSupportedException ("Parsing signatures with more than one primitive value is not supported (signature was '" + this + "')");
 201
 202             return new Signature (this[1]);
 203         }
 204
 205         public Type[] ToTypes ()
 206         {
 207             List<Type> types = new List<Type> ();
 208             for (int i = 0 ; i != data.Length ; types.Add (ToType (ref i)));
 209             return types.ToArray ();
 210         }
 211
 212         public Type ToType ()
 213         {
 214             int pos = 0;
 215             Type ret = ToType (ref pos);
 216             if (pos != data.Length)
 217                 throw new Exception ("Signature '" + Value + "' is not a single complete type");
 218             return ret;
 219         }
 220
 221         internal static DType TypeCodeToDType (TypeCode typeCode)
 222         {
 223             switch (typeCode)
 224             {
 225             case TypeCode.Empty:
 226                 return DType.Invalid;
 227             case TypeCode.Object:
 228                 return DType.Invalid;
 229             case TypeCode.DBNull:
 230                 return DType.Invalid;
 231             case TypeCode.Boolean:
 232                 return DType.Boolean;
 233             case TypeCode.Char:
 234                 return DType.UInt16;
 235             case TypeCode.SByte:
 236                 return DType.Byte;
 237             case TypeCode.Byte:
 238                 return DType.Byte;
 239             case TypeCode.Int16:
 240                 return DType.Int16;
 241             case TypeCode.UInt16:
 242                 return DType.UInt16;
 243             case TypeCode.Int32:
 244                 return DType.Int32;
 245             case TypeCode.UInt32:
 246                 return DType.UInt32;
 247             case TypeCode.Int64:
 248                 return DType.Int64;
 249             case TypeCode.UInt64:
 250                 return DType.UInt64;
 251             case TypeCode.Single:
 252                 return DType.Single;
 253             case TypeCode.Double:
 254                 return DType.Double;
 255             case TypeCode.Decimal:
 256                 return DType.Invalid;
 257             case TypeCode.DateTime:
 258                 return DType.Invalid;
 259             case TypeCode.String:
 260                 return DType.String;
 261             default:
 262                 return DType.Invalid;
 263             }
 264         }
 265
 266         //FIXME: this method is bad, get rid of it
 267         internal static DType TypeToDType (Type type)
 268         {
 269             if (type == typeof (void))
 270                 return DType.Invalid;
 271
 272             if (type == typeof (string))
 273                 return DType.String;
 274
 275             if (type == typeof (ObjectPath))
 276                 return DType.ObjectPath;
 277
 278             if (type == typeof (Signature))
 279                 return DType.Signature;
 280
 281             if (type == typeof (object))
 282                 return DType.Variant;
 283
 284             if (type.IsPrimitive)
 285                 return TypeCodeToDType (Type.GetTypeCode (type));
 286
 287             if (type.IsEnum)
 288                 return TypeToDType (Enum.GetUnderlyingType (type));
 289
 290             //needs work
 291             if (type.IsArray)
 292                 return DType.Array;
 293
 294             //if (type.UnderlyingSystemType != null)
 295             //  return TypeToDType (type.UnderlyingSystemType);
 296             if (Mapper.IsPublic (type))
 297                 return DType.ObjectPath;
 298
 299             if (!type.IsPrimitive && !type.IsEnum)
 300                 return DType.Struct;
 301
 302             //TODO: maybe throw an exception here
 303             return DType.Invalid;
 304         }
 305
 306         public Type ToType (ref int pos)
 307         {
 308             DType dtype = (DType)data[pos++];
 309
 310             switch (dtype) {
 311             case DType.Invalid:
 312                 return typeof (void);
 313             case DType.Byte:
 314                 return typeof (byte);
 315             case DType.Boolean:
 316                 return typeof (bool);
 317             case DType.Int16:
 318                 return typeof (short);
 319             case DType.UInt16:
 320                 return typeof (ushort);
 321             case DType.Int32:
 322                 return typeof (int);
 323             case DType.UInt32:
 324                 return typeof (uint);
 325             case DType.Int64:
 326                 return typeof (long);
 327             case DType.UInt64:
 328                 return typeof (ulong);
 329             case DType.Single: ////not supported by libdbus at time of writing
 330                 return typeof (float);
 331             case DType.Double:
 332                 return typeof (double);
 333             case DType.String:
 334                 return typeof (string);
 335             case DType.ObjectPath:
 336                 return typeof (ObjectPath);
 337             case DType.Signature:
 338                 return typeof (Signature);
 339             case DType.Array:
 340                 //peek to see if this is in fact a dictionary
 341                 if ((DType)data[pos] == DType.DictEntryBegin) {
 342                     //skip over the {
 343                     pos++;
 344                     Type keyType = ToType (ref pos);
 345                     Type valueType = ToType (ref pos);
 346                     //skip over the }
 347                     pos++;
 348                     //return typeof (IDictionary<,>).MakeGenericType (new Type[] {keyType, valueType});
 349                     //workaround for Mono bug #81035 (memory leak)
 350                     return Mapper.GetGenericType (typeof (IDictionary<,>), new Type[] {keyType, valueType});
 351                 }
 352                 else {
 353                     return ToType (ref pos).MakeArrayType ();
 354                 }
 355             case DType.Struct:
 356                 return typeof (ValueType);
 357             case DType.DictEntry:
 358                 return typeof (System.Collections.Generic.KeyValuePair<,>);
 359             case DType.Variant:
 360                 return typeof (object);
 361             default:
 362                 throw new NotSupportedException ("Parsing or converting this signature is not yet supported (signature was '" + this + "'), at DType." + dtype);
 363             }
 364         }
 365
 366         public static Signature GetSig (object[] objs)
 367         {
 368             return GetSig (Type.GetTypeArray (objs));
 369         }
 370
 371         public static Signature GetSig (Type[] types)
 372         {
 373             if (types == null)
 374                 throw new ArgumentNullException ("types");
 375
 376             Signature sig = Signature.Empty;
 377
 378             foreach (Type type in types)
 379                 sig += GetSig (type);
 380
 381             return sig;
 382         }
 383
 384         public static Signature GetSig (Type type)
 385         {
 386             if (type == null)
 387                 throw new ArgumentNullException ("type");
 388
 389             //this is inelegant, but works for now
 390             if (type == typeof (Signature))
 391                 return new Signature (DType.Signature);
 392
 393             if (type == typeof (ObjectPath))
 394                 return new Signature (DType.ObjectPath);
 395
 396             if (type == typeof (void))
 397                 return Signature.Empty;
 398
 399             if (type == typeof (string))
 400                 return new Signature (DType.String);
 401
 402             if (type == typeof (object))
 403                 return new Signature (DType.Variant);
 404
 405             if (type.IsArray)
 406                 return GetSig (type.GetElementType ()).MakeArraySignature ();
 407
 408             if (type.IsGenericType && (type.GetGenericTypeDefinition () == typeof (IDictionary<,>) || type.GetGenericTypeDefinition () == typeof (Dictionary<,>))) {
 409
 410                 Type[] genArgs = type.GetGenericArguments ();
 411                 return Signature.MakeDict (GetSig (genArgs[0]), GetSig (genArgs[1]));
 412             }
 413
 414             if (Mapper.IsPublic (type)) {
 415                 return new Signature (DType.ObjectPath);
 416             }
 417
 418             if (!type.IsPrimitive && !type.IsEnum) {
 419                 Signature sig = Signature.Empty;
 420
 421                 foreach (FieldInfo fi in type.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
 422                     sig += GetSig (fi.FieldType);
 423
 424                 return Signature.MakeStruct (sig);
 425             }
 426
 427             DType dtype = Signature.TypeToDType (type);
 428             return new Signature (dtype);
 429         }
 430     }
 431
 432     enum ArgDirection
 433     {
 434         In,
 435         Out,
 436     }
 437
 438     public enum DType : byte
 439     {
 440         Invalid        = (byte)'\0',
 441
 442         Byte           = (byte)'y',
 443         Boolean        = (byte)'b',
 444         Int16          = (byte)'n',
 445         UInt16         = (byte)'q',
 446         Int32          = (byte)'i',
 447         UInt32         = (byte)'u',
 448         Int64          = (byte)'x',
 449         UInt64         = (byte)'t',
 450         Single         = (byte)'f',
 451         Double         = (byte)'d',
 452         String         = (byte)'s',
 453         ObjectPath     = (byte)'o',
 454         Signature      = (byte)'g',
 455
 456         Array          = (byte)'a',
 457         Variant        = (byte)'v',
 458
 459         Struct         = (byte)'r',
 460         StructBegin    = (byte)'(',
 461         StructEnd      = (byte)')',
 462
 463         DictEntry      = (byte)'e',
 464         DictEntryBegin = (byte)'{',
 465         DictEntryEnd   = (byte)'}',
 466     }
 467 }