I know this has basically no chance of ever actually being added
because that is the way of all "I want feature X" threads, but I
thought I would post this anyways because I seem to want it
constantly.
So we have TemplateThisParameters methods which are cool but have
some drawbacks.
They are templates so they are implicitly non-virtual and are
called based on the type of the reference.
It would be very nice to be able to auto generate method
overrides based on the this type with out having to drop a mixin
in every sub class.
This would be very useful for CT-reflection.
I will call this new feature auto override methods for the rest
of this post.
An auto override method would take the form of a template method
with only a single type argument that is the type of the class or
any of it's sub classes.
To differentiate it from TemplateThisParameters it could look
like:
returnType functionName(auto override this T)() {...}
When ever a class with an auto override method is sub-classed,
the auto override method template is re-instantiated with the
sub-class type and the method is overridden automatically.
Key point is that the method will still be virtual.
Here is an example contrasting an auto override method with a
regular TemplateThisParameters method.
##################################
class A
{
void foo(this T)() { writeln(T.stringof); }
void bar(auto override this T)() { writeln(T.stringof); }
}
class B : A {}
void main()
{
A a = new A();
a.foo(); // prints "A"
a.bar(); // prints "A"
B b = new B();
b.foo(); // prints "B"
b.bar(); // prints "B"
A c = new B();
c.foo(); // prints "A"
c.bar(); // prints "B" <-- main advantage, method is virtual
}
##################################
Possible uses:
-Automatic generation of nice toString.
-Auto-generate property panes. This is actually a use I need
right now, to generate property panes for entity types in a game
engine(unity style).
-Another time I needed it, I have a UI system that will
automatically apply ui formatting based on the existence of
"stylize properties" that can be read at compile time, but it
required a virtual method to have to be redefined for each
sub-class which simply reflected on the this type and checked for
the existence of the "stylize properties".
-Check if a sub-class implements certain features
-Check if sub-class has a certain UDA
etc...
I find myself needing this a lot in my code, especially as I
write a lot of CT-reflection.
So far the only way I have found to achieve this is to drop a
string mixin in every subclass putting the override in.
Thoughts?
Any one else needed this before?
Any clever way to do this now that I have not thought of?
-Tofu
