These opAssign overloads are what puts the flexibility in the flexible delegate.
Calls the currently set delegate.
Use if(thing) to check if the delegate is null or not.
// you don't have to put the arguments in a struct, but i recommend // you do as it is more future proof - you can add more info to the // struct without breaking user code that consumes it. struct MyEventArguments { } // then you declare it just adding FlexibleDelegate!() around the // plain delegate type you'd normally use FlexibleDelegate!(void delegate(MyEventArguments args)) callback; // until you set it, it will be null and thus be false in any boolean check assert(!callback); // can set it to the properly typed thing callback = delegate(MyEventArguments args) {}; // and now it is no longer null assert(callback); // or if you don't care about the args, you can leave them off callback = () {}; // and it works if the compiler types you as a function instead of delegate too // (which happens automatically if you don't access any local state or if you // explicitly define it as a function) callback = function(MyEventArguments args) { }; // can set it back to null explicitly if you ever wanted callback = null; // the reflection info used internally also happens to be exposed publicly // which can actually sometimes be nice so if the language changes, i'll change // the code to keep this working. static assert(is(callback.ReturnType == void)); // which can be convenient if the params is an annoying type since you can // consistently use something like this too callback = (callback.Parameters params) {}; // check for null and call it pretty normally if(callback) callback(MyEventArguments());
Declares a delegate property with several setters to allow for handlers that don't care about the arguments.
Throughout the arsd library, you will often see types of these to indicate that you can set listeners with or without arguments. If you care about the details of the callback event, you can set a delegate that declares them. And if you don't, you can set one that doesn't even declare them and it will be ignored.