xplcidl/masterdispatch.h

   1 #ifndef __MASTERDISPATCH_H
   2 #define __MASTERDISPATCH_H
   3
   4 #include "anytype.h"
   5 #include "wvhashtable.h"
   6
   7 typedef AnyType (GenFunc)(AnyType &self, AnyType parms[]);
   8
   9 struct CallEntry {
  10     const char *name;
  11     GenFunc *func;
  12     int argc;
  13     const UUID *argtypes;
  14 };
  15
  16
  17 class IfcInfo
  18 {
  19 public:
  20     IfcInfo(WvStringParm _iname, const UUID &_iid,
  21             CallEntry *_calls, int _ncalls);
  22     ~IfcInfo();
  23
  24     WvString iname;
  25     const UUID &iid;
  26
  27     CallEntry *calls;
  28     int ncalls;
  29 };
  30
  31
  32 static inline int WvHash(const UUID &uuid)
  33 {
  34     // it's random!  any four bytes are as good as any others.
  35     return WvHash(*(int *)&uuid);
  36 }
  37
  38 DeclareWvDict(IfcInfo, UUID, iid);
  39
  40 class MasterDispatch
  41 {
  42 public:
  43     IfcInfoDict ifcs;
  44
  45     MasterDispatch()
  46         : ifcs(10)
  47         { }
  48     ~MasterDispatch()
  49         { /* nothing special */ }
  50
  51     void add(IfcInfo *info)
  52         { ifcs.add(info, false); }
  53     void remove(IfcInfo *info)
  54         { ifcs.remove(info); }
  55
  56     CallEntry *find(AnyType &self, WvStringParm fname, int argc,
  57                     AnyType parms[])
  58     {
  59         // FIXME: this is stupid.  We have a hash table of interfaces that
  60         // we iterate through, but we should have a hash table of function
  61         // names with a list of CallEntry for each name.  That would be
  62         // much faster, but this is easier, so it'll do for now.
  63         IfcInfoDict::Iter ifc(ifcs);
  64         for (ifc.rewind(); ifc.next(); )
  65         {
  66             //printf("dispatch: checking interface '%s'\n", ifc->iname.cstr());
  67             bool ret = self.switchto(ifc->iid);
  68             //printf("   switch: %p -> %d\n", (IObject *)self.obj, ret);
  69             if (!ret) continue; // incompatible object
  70
  71             for (int i = 0; i < ifc->ncalls; i++)
  72             {
  73                 CallEntry &ent = ifc->calls[i];
  74                 //printf("  dispatch: checking func '%s'\n", ent.name);
  75
  76                 if (fname != ent.name) continue;
  77                 if (ent.argc != argc) continue;
  78                 assert(!argc || ent.argtypes);
  79
  80                 bool ok = true;
  81                 for (int arg = 0; arg < argc; arg++)
  82                 {
  83                     if (!parms[arg].switchto(ent.argtypes[arg]))
  84                     {
  85                         ok = false;
  86                         break;
  87                     }
  88                 }
  89                 if (!ok) continue;
  90
  91                 // if we get here, we found a match!
  92                 // printf("found entry '%s' (%p)\n", ent.name, &ent);
  93                 return &ent;
  94             }
  95         }
  96
  97         // whoops, no match!
  98         return NULL;
  99     }
 100
 101     AnyType call(AnyType &self, WvStringParm fname, int argc, AnyType parms[])
 102     {
 103         CallEntry *ent = find(self, fname, argc, parms);
 104         assert(ent);
 105         return ent->func(self, parms);
 106     }
 107 };
 108
 109
 110 extern MasterDispatch *master;
 111
 112
 113 #endif // __MASTERDISPATCH_H