Automatic dynamic dispatch

[Jacob Carlborg]

On 2013-02-06 05:37, Andrej Mitrovic wrote:
> Someone asked about how to invoke a function with the dynamic type of
> an object. Essentially the user wanted to implement functions external
> to a class without touching the class vtable (he might not have access
> to it if it's in another library), but he explicitly wanted to work on
> the derived type and not the base type, for example:
>
> class A { }
> class B : A { }
> class C : B { }
>
> void foo(B b) { }  // requires B or derived from B, not A
> void foo(C c) { }  // requires C or derived from C, not A
>
> Since all classes have a TypeInfo_Class associated with them, we can
> create a few helper templates which figure out the entire class tree
> from a set of leaf classes, and then tries to dynamically dispatch to
> the appropriate function at runtime.
>
> Here's the code to do just that: http://dpaste.dzfl.pl/8338067b
>
> And pasted here for convenience:
>
> import std.stdio;
> import std.typetuple;
> import std.traits;
> import std.string;
>
> class A { }
> class B : A { }
> class C : B { }
> class D : B { }
>
> template ClassTreeImpl(Leaves...)
> {
>      static if (Leaves.length > 1)
>      {
>          alias TypeTuple!(Leaves[0], BaseClassesTuple!(Leaves[0]),
>                           ClassTreeImpl!(Leaves[1..$])) ClassTreeImpl;
>      }
>      else
>      static if (Leaves.length == 1)
>      {
>          alias TypeTuple!(Leaves[0], BaseClassesTuple!(Leaves[0])) ClassTreeImpl;
>      }
>      else
>      {
>          alias TypeTuple!() ClassTreeImpl;
>      }
> }
>
> template ClassTree(Leaves...)
> {
>      alias DerivedToFront!(NoDuplicates!(ClassTreeImpl!(Leaves))) ClassTree;
> }
>
> void callFunc(alias func, Args...)(Args args)
>      if (Args.length >= 1 && is(Args[0] == class))
> {
>      auto objInfo = typeid(args[0]);
>      foreach (Base; ClassTree!(C, D))
>      {
>          if (objInfo == Base.classinfo)
>          {
>              static if (__traits(compiles,  // avoid CT errors due to
> unrolled static foreach
>                  { return func(cast(Base)(cast(void*)args[0]),
> args[1..$]); }() ))
>              {
>                  return func(cast(Base)(cast(void*)args[0]), args[1..$]);
>              }
>          }
>      }
>
>      assert(0, format("function '%s' is not callable with object of
> dynamic type '%s'",
>                       __traits(identifier, func), objInfo.toString()));
> }
>
> void foo(C c, int x) { writefln("foo(C) : received %s", x); }
> void foo(D d, int x, int y) { writefln("foo(D) : received %s %s", x, y); }
>
> void main()
> {
>      A c = new C;
>      A d = new D;
>      A a = new A;
>
>      callFunc!foo(c, 1);    // ok
>      callFunc!foo(d, 2, 3); // ok
>      callFunc!foo(a, 3);    // will assert at runtime
> }
>
> It would have been a good blog entry, but I don't blog so.. :)

That's pretty cool.

-- 
/Jacob Carlborg