src/type.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * type.cpp: Our type system
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17
  18 #include "type.h"
  19 #include "runtime.h"
  20 #include "deployment.h"
  21 #include "dependencyproperty.h"
  22
  23 /*
  24  * Type implementation
  25  */
  26 Type::Type (Type::Kind type, Type::Kind parent, bool is_value_type, bool is_interface,
  27             const char *name,
  28             int event_count, int total_event_count, const char **events,
  29             int interface_count, const Type::Kind *interfaces, bool ctor_visible,
  30             create_inst_func *create_inst, const char *content_property)
  31 {
  32         this->type = type;
  33         this->parent = parent;
  34         this->is_value_type = is_value_type;
  35         this->is_interface = is_interface;
  36         this->name = name;
  37         this->event_count = event_count;
  38         this->total_event_count = total_event_count;
  39         this->events = events;
  40         this->ctor_visible = ctor_visible;
  41         this->create_inst = create_inst;
  42         this->content_property = content_property;
  43         this->properties = NULL;
  44         this->interface_count = interface_count;
  45         if (this->interface_count) {
  46                 this->interfaces = new Type::Kind[interface_count];
  47                 memcpy (this->interfaces, interfaces, interface_count * sizeof (Type::Kind));
  48         }
  49         else {
  50                 this->interfaces = NULL;
  51         }
  52 }
  53
  54 Type::~Type ()
  55 {
  56         if (properties) {
  57                 g_hash_table_destroy (properties);
  58                 properties = NULL;
  59         }
  60
  61         delete [] interfaces;
  62 }
  63
  64 const char *
  65 Type::LookupEventName (int id)
  66 {
  67         Type *parent_type = Type::Find (parent);
  68         int parent_event_count = (parent_type == NULL ? 0 : parent_type->total_event_count);
  69         int current_id;
  70         const char *result;
  71
  72         if (id < 0)
  73                 return "";
  74
  75         if (events != NULL) {
  76                 for (int i = 0; events [i] != NULL; i++) {
  77                         current_id = i + parent_event_count;
  78                         if (current_id == id)
  79                                 return events [i];
  80                 }
  81         }
  82
  83         if (parent == Type::INVALID || parent_type == NULL) {
  84                 printf ("Event lookup of event id %i in type '%s' failed.\n", id, name);
  85                 return NULL;
  86         }
  87
  88         result = parent_type->LookupEventName (id);
  89
  90         if (result == NULL)
  91                 printf ("Event lookup of event %i in (more exactly) type '%s' failed.\n", id, name);
  92
  93         return result;
  94 }
  95
  96 int
  97 Type::LookupEvent (const char *event_name)
  98 {
  99         Type *parent_type = Type::Find (parent);
 100         int result;
 101
 102         if (events != NULL) {
 103                 for (int i = 0; events [i] != NULL; i++) {
 104                         if (!g_ascii_strcasecmp (events [i], event_name))
 105                                 return i + (parent_type == NULL ? 0 : parent_type->total_event_count);
 106                 }
 107         }
 108
 109         if (parent == Type::INVALID || parent_type == NULL) {
 110                 printf ("Event lookup of event '%s' in type '%s' failed.\n", event_name, name);
 111                 return -1;
 112         }
 113
 114         result = parent_type->LookupEvent (event_name);
 115
 116         if (result == -1)
 117                 printf ("Event lookup of event '%s' in (more exactly) type '%s' failed.\n", event_name, name);
 118
 119         return result;
 120 }
 121
 122 bool
 123 Type::IsSubclassOf (Deployment *deployment, Type::Kind type, Type::Kind super)
 124 {
 125         return deployment->GetTypes ()->IsSubclassOf (type, super);
 126 }
 127
 128 bool
 129 Type::IsSubclassOf (Type::Kind type, Type::Kind super)
 130 {
 131         return IsSubclassOf (Deployment::GetCurrent (), type, super);
 132 }
 133
 134 bool
 135 Type::IsSubclassOf (Deployment *deployment, Type::Kind super)
 136 {
 137         return deployment->GetTypes ()->IsSubclassOf (type, super);
 138 }
 139
 140 bool
 141 Type::IsSubclassOf (Type::Kind super)
 142 {
 143         return IsSubclassOf (Deployment::GetCurrent (), type, super);
 144 }
 145
 146 bool
 147 Types::IsSubclassOrSuperclassOf (Type::Kind unknown, Type::Kind known)
 148 {
 149         return IsSubclassOf(unknown, known) || IsSubclassOf (known, unknown);
 150 }
 151
 152 bool
 153 Types::IsSubclassOrSuperclassOf (Types *arg, Type::Kind unknown, Type::Kind known)
 154 {
 155         Types *types = arg == NULL ? Deployment::GetCurrent ()->GetTypes () : arg;
 156         return types->IsSubclassOf(unknown, known) || types->IsSubclassOf (known, unknown);
 157 }
 158
 159
 160 bool
 161 Types::IsSubclassOf (Type::Kind type, Type::Kind super)
 162 {
 163         Type *t;
 164         Type::Kind parent;
 165
 166         if (type == Type::INVALID)
 167                 return false;
 168
 169         if (type == super)
 170                 return true;
 171
 172         t = Find (type);
 173
 174         g_return_val_if_fail (t != NULL, false);
 175
 176         do {
 177                 parent = t->GetParent ();
 178
 179                 if (parent == super)
 180                         return true;
 181
 182                 if (parent == Type::INVALID)
 183                         return false;
 184
 185                 t = Find (parent);
 186
 187                 if (t == NULL)
 188                         return false;
 189         } while (true);
 190
 191         return false;
 192 }
 193
 194 bool
 195 Type::IsAssignableFrom (Type::Kind type)
 196 {
 197         return Deployment::GetCurrent ()->GetTypes ()->IsAssignableFrom (GetKind (), type);
 198 }
 199
 200 bool
 201 Type::IsAssignableFrom (Type::Kind destination, Type::Kind type)
 202 {
 203         return Deployment::GetCurrent ()->GetTypes ()->IsAssignableFrom (destination, type);
 204 }
 205
 206 bool
 207 Types::IsAssignableFrom (Type::Kind destination, Type::Kind type)
 208 {
 209         if (destination == type)
 210                 return true;
 211
 212         if (IsSubclassOf (type, destination))
 213                 return true;
 214
 215         // more expensive..  interface checks
 216         Type *destination_type = Find (destination);
 217         if (!destination_type->IsInterface())
 218                 return false;
 219
 220         Type *type_type = Find (type);
 221         while (type_type && type_type->GetKind() != Type::INVALID) {
 222                 for (int i = 0; i < type_type->GetInterfaceCount(); i ++) {
 223                         // should this be IsAssignableFrom instead of ==?  ugh
 224                         if (type_type->GetInterface(i) == destination)
 225                                 return true;
 226                 }
 227                 type_type = Find (type_type->GetParent());
 228         }
 229
 230         return false;
 231 }
 232
 233 Type *
 234 Type::Find (Deployment *deployment, const char *name)
 235 {
 236         return deployment->GetTypes ()->Find (name);
 237 }
 238
 239 Type *
 240 Type::Find (const char *name)
 241 {
 242         return Find (Deployment::GetCurrent (), name);
 243 }
 244
 245 Type *
 246 Type::Find (Deployment *deployment, const char *name, bool ignore_case)
 247 {
 248         return deployment->GetTypes ()->Find (name, ignore_case);
 249 }
 250
 251 Type *
 252 Type::Find (const char *name, bool ignore_case)
 253 {
 254         return Find (Deployment::GetCurrent (), name, ignore_case);
 255 }
 256
 257 Type *
 258 Type::Find (Deployment *deployment, Type::Kind type)
 259 {
 260         if (type < Type::INVALID || type == Type::LASTTYPE)
 261                 return NULL;
 262
 263         return deployment->GetTypes ()->Find (type);
 264 }
 265
 266 Type *
 267 Type::Find (Type::Kind type)
 268 {
 269         if (type < Type::INVALID || type == Type::LASTTYPE)
 270                 return NULL;
 271
 272         return Find (Deployment::GetCurrent (), type);
 273 }
 274
 275 DependencyObject *
 276 Type::CreateInstance ()
 277 {
 278         if (!create_inst) {
 279                 g_warning ("Unable to create an instance of type: %s\n", name);
 280                 return NULL;
 281         }
 282
 283         return create_inst ();
 284 }
 285
 286 const char *
 287 Type::GetContentPropertyName ()
 288 {
 289         Type *parent_type;
 290
 291         if (type == INVALID)
 292                 return NULL;
 293
 294         if (content_property)
 295                 return content_property;
 296
 297         parent_type = Find (parent);
 298
 299         if (parent_type == NULL)
 300                 return NULL;
 301
 302         return parent_type->GetContentPropertyName ();
 303 }
 304
 305 DependencyProperty *
 306 Type::LookupProperty (const char *name)
 307 {
 308         DependencyProperty *property = NULL;
 309
 310         g_return_val_if_fail (name != NULL, NULL);
 311
 312         if (properties != NULL) {
 313                 char *key = g_ascii_strdown (name, -1);
 314                 property = (DependencyProperty*) g_hash_table_lookup (properties, key);
 315                 g_free (key);
 316
 317                 if (property)
 318                         return property;
 319         }
 320
 321         return NULL;
 322 }
 323
 324 void
 325 Type::AddProperty (DependencyProperty *property)
 326 {
 327         DependencyProperty *existing = NULL;
 328
 329         g_return_if_fail (property != NULL);
 330
 331         if (properties == NULL) {
 332                 properties = g_hash_table_new (g_str_hash, g_str_equal);
 333         } else {
 334                 existing = (DependencyProperty *) g_hash_table_lookup (properties, property->GetHashKey ());
 335         }
 336
 337         if (existing == NULL || existing->IsCustom ()) {
 338                 // Allow overwriting of custom properties
 339                 g_hash_table_insert (properties, (gpointer) property->GetHashKey (), property);
 340         } else {
 341                 g_warning ("Type::AddProperty (): Trying to register the property '%s' (of type %s) in the owner type '%s', and there already is a property registered on that type with the same name.",
 342                            property->GetName (), Type::Find (property->GetPropertyType ())->GetName(), GetName());
 343         }
 344 }
 345
 346 static void
 347 property_add (gpointer key, gpointer value, gpointer user_data)
 348 {
 349         g_hash_table_insert ((GHashTable *) user_data, key, value);
 350 }
 351
 352 GHashTable *
 353 Type::CopyProperties (bool inherited)
 354 {
 355         GHashTable *props = g_hash_table_new (g_str_hash, g_str_equal);
 356         Type *type = this;
 357
 358         do {
 359                 if (type->properties)
 360                         g_hash_table_foreach (type->properties, property_add, props);
 361
 362                 if (!inherited || type->GetParent () == Type::INVALID)
 363                         break;
 364
 365                 type = Type::Find (type->GetParent ());
 366         } while (type);
 367
 368         return props;
 369 }
 370
 371 bool
 372 type_get_value_type (Type::Kind type)
 373 {
 374         Type *t = Type::Find (type);
 375
 376         if (t == NULL)
 377                 return false;
 378
 379         return t->IsValueType ();
 380 }
 381
 382 const char *
 383 type_get_name (Type::Kind type)
 384 {
 385         Type *t = Type::Find (type);
 386
 387         if (t == NULL)
 388                 return NULL;
 389
 390         return t->GetName ();
 391 }
 392
 393 bool
 394 type_is_dependency_object (Type::Kind type)
 395 {
 396         return Type::IsSubclassOf (type, Type::DEPENDENCY_OBJECT);
 397 }
 398
 399 DependencyObject *
 400 type_create_instance (Type *type)
 401 {
 402         if (!type) {
 403                 g_warning ("Unable to create instance of type %p.", type);
 404                 return NULL;
 405         }
 406
 407         return type->CreateInstance ();
 408 }
 409
 410 DependencyObject *
 411 type_create_instance_from_kind (Type::Kind kind)
 412 {
 413         Type *t = Type::Find (kind);
 414
 415         if (t == NULL) {
 416                 g_warning ("Unable to create instance of type %d. Type not found.", kind);
 417                 return NULL;
 418         }
 419
 420         return t->CreateInstance ();
 421 }
 422
 423 /*
 424  * Types
 425  */
 426
 427 Types::Types ()
 428 {
 429         //printf ("Types::Types (). this: %p\n", this);
 430         types.SetCount ((int) Type::LASTTYPE + 1);
 431         RegisterNativeTypes ();
 432 }
 433
 434 void
 435 Types::Initialize ()
 436 {
 437         RegisterNativeProperties ();
 438 }
 439
 440 void
 441 Types::DeleteProperties ()
 442 {
 443         /* this can't be done in the destructor, since deleting the properties might end up accessing the types */
 444         for (int i = 0; i < properties.GetCount (); i++)
 445                 delete (DependencyProperty *) properties [i];
 446         properties.SetCount (0);
 447 }
 448
 449 void
 450 Types::Dispose ()
 451 {
 452         for (int i = 0; i < properties.GetCount (); i++)
 453                 ((DependencyProperty *) properties [i])->Dispose ();
 454 }
 455
 456 Types::~Types ()
 457 {
 458         for (int i = 0; i < types.GetCount (); i++)
 459                 delete (Type *) types [i];
 460 }
 461
 462 void
 463 Types::AddProperty (DependencyProperty *property)
 464 {
 465         Type *type;
 466
 467         g_return_if_fail (property != NULL);
 468
 469         type = Find (property->GetOwnerType ());
 470
 471         g_return_if_fail (type != NULL);
 472
 473         property->SetId (properties.Add (property));
 474         type->AddProperty (property);
 475 }
 476
 477 DependencyProperty *
 478 Types::GetProperty (int id)
 479 {
 480         g_return_val_if_fail (properties.GetCount () > id, NULL);
 481         return (DependencyProperty *) properties [id];
 482 }
 483
 484 Type *
 485 Types::Find (Type::Kind type)
 486 {
 487         if ((int) type + 1 > types.GetCount ())
 488                 return NULL;
 489
 490         return (Type *) types [(int) type];
 491 }
 492
 493 Type *
 494 Types::Find (const char *name)
 495 {
 496         return Types::Find (name, true);
 497 }
 498
 499 Type *
 500 Types::Find (const char *name, bool ignore_case)
 501 {
 502         Type *t;
 503
 504         for (int i = 1; i < types.GetCount (); i++) { // 0 = INVALID, shouldn't compare against that
 505                 if (i == Type::LASTTYPE)
 506                         continue;
 507
 508                 t = (Type *) types [i];
 509                 if ((ignore_case && !g_ascii_strcasecmp (t->GetName (), name)) || !strcmp (t->GetName (), name))
 510                         return t;
 511         }
 512
 513         return NULL;
 514 }
 515
 516 Type::Kind
 517 Types::RegisterType (const char *name, void *gc_handle, Type::Kind parent, bool is_interface, bool ctor_visible, Type::Kind* interfaces, int interface_count)
 518 {
 519         Type *type = new Type (Type::INVALID, parent, false, is_interface, g_strdup (name), 0, Find (parent)->GetEventCount (), NULL, interface_count, interfaces, ctor_visible, NULL, NULL);
 520
 521         // printf ("Types::RegisterType (%s, %p, %i (%s)). this: %p, size: %i, count: %i\n", name, gc_handle, parent, Type::Find (this, parent) ? Type::Find (this, parent)->name : NULL, this, size, count);
 522
 523         type->SetKind ((Type::Kind) types.Add (type));
 524
 525         return type->GetKind ();
 526 }
 527