Am 16.10.2013 10:40, schrieb DoctorCaptain:
On Wednesday, 16 October 2013 at 06:09:48 UTC, Benjamin Thaut wrote:
Am 16.10.2013 03:17, schrieb DoctorCaptain:
I've gotten extremely close. The DPaste link that follows demonstrates
three different templates:
...
So is there any reason why you still pass the variadic arguments to
the generator function and not do it the way I proposed in my last
dpaste snippet? Even if you need the variadic arguments inside the
generator for some logic you could still reference them by using the
variadic arguments to the actual template.
I suppose I was trying to give the class individual data members, such
that passing a tuple of (WorstChild, MiddleChild, BestChild) would
result in a class definition of:
class MagicClass {
WorstClass t1;
MiddleClass t2;
BestClass t3;
}
However, if that is impossible (and frankly it'd be more difficult to
work with than your way even if it was achieved), then I'll use your
approach (actually, I'm just going to use your approach anyway. It's
significantly cleaner than my horrid mess of a goal). That said, what is
actually happening in your example?
I reworked it a bit to demonstrate that the class has accessible members
within T, that can be instantiated and accessed and whatnot.
http://dpaste.dzfl.pl/07b20d75
Note the use of typeof() to get the type of the elements at each index
of members, to generate a type on which a constructor can be called to
instantiate the elements at each index of members. Magic.
What is T within the generated class definition? Is this just how tuples
work? T is an "array" of three arbitrary pointers, initially null, that
can be instantiated with new to create valid pointers to objects of each
type at T's indexes? Like, T in the DPaste example is an array of
pointers, such that:
[WorstChild*, MiddleChild*, BestChild*]? Is it literally just magic like
that?
Actually, let me formally present a couple of ending thoughts/questions:
First, allow me to apologize for trying to force a different, messy
horrid mess of a goal on you, when your initial solution was majestic to
begin with.
No problem, I can understand that you want to stick with your solution.
But as Artur explained the template is actually not able to see the
actual types directly and thats why full qualified identifier will not work.
Second, as I was trying to figure out just a moment ago, what -exactly-
is T in the generated class definition, and why does it allow me to use
it as an arbitrary container for objects of the arbitrary types I want
it to contain (Read: why is it able to do exactly what I want it to be
able to do? What's going on behind the scenes?)?
T is the variadic argument T that is passed to the actual template
"GrabBagT". It might become more clear when actually copy & pasting the
generated code into the template. The problem is that you try to
reference the classes by name. Thats not necessary. You get the classes
passed in as template arguments. So you just reference them as template
arguments instead of referencing them by name. It is possible to do so
by not generating access via the name but instead use the template
arguments passed to GrabBagT. I hope this made it a bit more clear. I
might have some more time later today to look into your new examples and
modify them.
Third, given that I am going to go with your solution (it works, it
works well, and I can't seem to force my original goal to work, whether
that was even a good idea to begin with at all (it wasn't)), can you
think of a way to actually produce my original goal? That is, instead of
a container T which I can use to access my arbitrary data members once
the generated class is instantiated, is it actually even possible to
generate individual data members, a la:
class MagicClass {
T[0] t0;
T[1] t1;
// ... etc
} // ?
What do you need individual data members for? In my example the "T
members" is actually a instance of a tuple which actually comes down to
the exakt same data layout like individual data members. The only
difference is that you access them by index and not by name. Which is
actually a plus if you ask me for generic programming. You can even get
back the tuple by doing typeof(members);
You've been wildly helpful, and admirably concise. I am -extremely-
interested in the answer to the second thought, and while I'm sure the
answer is simple, it also seems -too- magic to actually work, and yet it
does.
Again, thank you to everyone who responded, and thank you Benjamin for
your continued help.
No problem. I love the metaprogramming abilities of D and a occansional
challenge is always welcome ;-)
--
Kind Regards
Benjamin Thaut
