On Tuesday, 12 July 2016 at 11:26:20 UTC, jj75607 wrote:
I want to use aspect-like annotations to transform
[...]
Two methods spring to mind but both create new types.
You can either write a function that iterates through the members
of your class, generating a string mixin that selectively hijacks
calls to functions you have annotated with some UDA. Then it
would just forward the function call inside synchronized blocks.
alias this should hopefully be enough to forward other members.
See https://dpaste.dzfl.pl/6a9cc4946caf for a rough example. It's
not robust, doesn't work with overloads (needs an additional
foreach over __traits(getOverloads, C, memberstring)), but I hope
it conveys the idea.
The alternative is to write a wrapper that similarly hijacks and
wraps calls inside synchronized blocks, but by using opDispatch.
The approach is less complex but sadly doesn't work as well;
alias this seems to be more or less mutually exclusive to
opDispatch, which makes sense. See
https://dpaste.dzfl.pl/a5dac71ab4f8. Accessing enums and other
types is also iffy since functions can't return types. As long as
you make the base class instance public you can always bypass
things that way.
In both examples it may make sense to have the generated
functions return via auto ref, it depends on your use cases.
