compile-time variables?

[Fraser]

Thanks. Yeah, that seems to work, but Bill is right - generating the IDs is probably simpler than trying to ensure I keep a reference to the template each time. Since it might need to go between multiple files, I think I'm probably going to have to look for a runtime solution, anyway. Thanks for your help.

Pragma Wrote:

> Bill Baxter wrote:
> > Pragma wrote:
> >> Fraser wrote:
> >>> Thanks for the ideas! Unfortunately, it doesn't seem to be working 
> >>> (either way). Here's the complete code I tried:
> >>>
> >>> --------------------
> >>> import tango.io.Stdout;
> >>>
> >>> char[] ctfe_itoa(uint value)
> >>> {
> >>>     if (value < 10) return "0123456789"[value .. value+1];
> >>>     return ctfe_itoa(value / 10) ~ ctfe_itoa(value % 10);
> >>> }
> >>>
> >>> uint Counter(){
> >>>     return 1;
> >>> }
> >>>
> >>> uint Counter(in uint value){
> >>>     return value+1;
> >>> }
> >>>
> >>> uint nextID()
> >>> {
> >>>     const auto first = Counter();
> >>>     const auto second = Counter(first);
> >>>     const auto third = Counter(second);
> >>>     return third;
> >>> }
> >>>
> >>> template Foo(char[] name)
> >>> {        const char[] text = "const char[] " ~ name ~ " = \"Name: " ~ 
> >>> name ~ ", ID: " ~ ctfe_itoa(nextID()) ~ "\n\";";
> >>> }
> >>>
> >>> mixin(Foo!("a").text);
> >>> mixin(Foo!("b").text);
> >>> mixin(Foo!("c").text);
> >>> mixin(Foo!("d").text);
> >>> mixin(Foo!("e").text);
> >>> mixin(Foo!("f").text);
> >>>
> >>> int main(char[][] args)
> >>> {
> >>>     Stdout(a)(b)(c)(d)(e)(f);
> >>>     return 0;
> >>> }
> >>> --------------------
> >>>
> >>> The result was:
> >>> Name: a, ID: 3
> >>> Name: b, ID: 3
> >>> Name: c, ID: 3
> >>> Name: d, ID: 3
> >>> Name: e, ID: 3
> >>> Name: f, ID: 3
> >>>
> >>> A similar thing happened with the template example.
> >>
> >> You need to prime your sequence with the zero counter value, and then 
> >> keep passing a template instance around to continue to count up:
> >>
> >> template StartCounter(){
> >>     const uint next = 0;
> >> }
> >>
> >> template Foo(char[] name,alias counter)
> >> {
> >>     const char[] text = "const char[] " ~ name ~ " = \"Name: " ~ name 
> >> ~ ", ID: " ~ ctfe_itoa(counter.next) ~ "\n\";";
> >>     const uint next = counter.next + 1;
> >> }
> >>
> >> alias Foo!("a",StartCounter!()) foo_a;
> >> alias Foo!("b",foo_a) foo_b;
> >> alias Foo!("c",foo_b) foo_c;
> >> alias Foo!("d",foo_c) foo_d; // <-- note how we feed the previous 
> >> template back into the next template instance
> >> alias Foo!("e",foo_d) foo_e;
> >>
> >> mixin(foo_a.text);
> >> mixin(foo_b.text);
> >> mixin(foo_c.text);
> >> mixin(foo_d.text);
> >> mixin(foo_e.text);
> >>
> > 
> > The problem with that (I'm assuming) is that if he could arrange it so 
> > that the generated code contained a nice ordered sequence of template 
> > names in increasing order, then that means he could also just as easily 
> > generate IDs themselves without going through all the template hoops.
> > 
> > --bb
> 
> Possibly.  It all depends on the complexity of his solution - the trivial example above doesn't do it much justice. 
> Where this really comes in handy is when you need to repeat any such block of declarations:
> 
> template Foo!(alias counter){
> 	alias Foo!("a",StartCounter!()) foo_a;
> 	alias Foo!("b",foo_a) foo_b;
> 	alias Foo!("c",foo_b) foo_c;
> 
> 	mixin(foo_a.text);
> 	mixin(foo_b.text);
> 	mixin(foo_c.text);
> 
> 	alias foo_c.next next; // save the counter state for the next use
> }
> 
> alias Foo!(StartCounter!()) foo1;
> alias Foo!(foo1) foo2;
> alias Foo!(foo2) foo3;
> 
> -- 
> - EricAnderton at yahoo