I have something like:
template myStruct(T){
auto makeMyStruct(T,E)(T context, void delegate(E) myFunc){
static struct myObject {
this(T context, void delegate(E) myFunc){
_context = context;
_myFunc = myFunc;
}
private:
void delegate(E) _myFunc;
T _context;
}
}
}
class myClass {
void myClassFunc();
}
myClass mc = new myClass;
auto mo = makeMyStruct!myClass(mc, &mc.myClassFunc); // mo = myObject
So, I need to carry around the object from which a delegate was created
from because it's not possible to query the delegate for the object
later somewhere else in the code.
Now, I want to keep several of the makeMyStruct!... created objects in
an AA (or an other container) so that I can compare them with an object
pointer. Like this (not working code, just pseudo code):
myObject[string] myObjectArray;
auto mo1 = makeMyStruct!myClassA(mcA, &mcA.myClassFunc); // mo1 = myObject
auto mo2 = makeMyStruct!myClassB(mcB, &mcA.myClassFunc); // mo2 = myObject
myObjectArray["1"] = mo1;
myObjectArray["2"] = mo2;
assert(mcA == mo1._context)
assert(mcA == myObjectArray["1"]._context)
I hope the idea is understandable. Of course this doesn't work because
myObjectArray needs a template, which creates different types. But with
different types I can't throw everything into on array. May claases,
and inheritance from a non-template base type help here?
I would like to keep it as simple as possible...
--
Robert M. Münch
http://www.saphirion.com
smarter | better | faster
