The Final(ize) Challenge

[Guillaume B.]

Andrei Alexandrescu wrote:
> 
> For starters, I'd like to present you with the following challenge.
> Given any class C, e.g.:
> 
> class C
> {
>      void foo(int) { ... }
>      int bar(string) { ... }
> }
> 
> define a template class Finalize(T) such that Finalize!(C) is the same
> as the following hand-written class:
> 
> final class FinalizeC : C
> {
>      final void foo(int a) { return super.foo(a); }
>      final int bar(string a) { return super.bar(a); }
> }
> 
> Finalize is cool when you need some functionality from an exact class
> and you don't want to pay indirect calls throughout. All calls through
> Finalize!(C)'s methods will resolve to static calls.
> 

 Hi,

 I don't fully understand the uses of Finalize!(C)... But for logging (or
timing), this kind of template could be useful... it think!... Anyway,
something like this:

class MagicLog(T) : T
{
// D Magic...
}

Could turn a class like this:

class C
{
   int foo() { ... }
}

to this:

class MagicLogC
{
   int foo() {
      Log.write("Entering foo()");
      scope(success) Log.write("Leaving foo(): success");
      scope(failure) Log.write("Leaving foo(): failure");
      return super.foo();
   }
}

And then, somewhere else:

version(WithMagicLog) {
   C c = new MagicLog!(C); // With logging
} else {
   C c = new C; // Full speed, no logging
}
int i = c.foo();

 Seems pretty useful to me! :) The only problem is writing the MagicLog
class.

 Guillaume B.