Templated structs / variant values

[Jacob Carlborg]

On 2013-08-15 00:29, Marek Janukowicz wrote:
> I need to have a generalized "settings" functionality that should work like
> this:
> * I need to be able to add this to a class
> * each setting has its name, description, type and default value
> * I need to iterate over all settings for given object
>
> API would more or less look like:
> class A {
>   ... here I somehow define a setting called "maxTime"
> }
>
> A a = new A();
>
> auto b = a.settings["maxTime"].value; // b would contain default value,
> because it wasn't set explicitly yet
> string s = a.settings["maxTime"].description; // s would contain setting
> description
> a.settings["maxTime"].value = 10.seconds; // This would only work if maxTime
> setting is of type duration
> foreach( name, value; a.settings ) ...
>
> Now the problem that I have is with storing those settings. What I've come
> up with so far are either Variants or templated structs (either really
> templated and type parametrized structs returned from template functions).
> The problem with variants is that I don't know how to force the value to be
> of certain type (variant accepts anything). As for templates and structs I
> tried something like:
>
> auto setting (string name, string description, T, T deflt)() {
>    struct Setting {
>      string name = name;
>      T value;
>    }
>    return Setting(name, deflt);
> }
>
> but then I don't know if there is any way to build an array of those to be
> able to iterate over them.
>
> I know generally there should be some kind of "setting definition" defined
> on class level that would keep shared information (like names and defaults)
> and then per-instance data containing just actual values, but I don't really
> care and any solution where this shared information is copied for every
> instance would also be fine.
>
> I know the description above is a bit messy (it's quite late now), but
> hopefully you can get the picture. Any ideas how to approach this problem?
>

Perhaps you can do something like this:

struct Setting (T, string desc)
{
     T value;
     enum description = desc;
     alias value this;

     this (T value)
     {
         this.value = value;
     }
}

class A
{
     Setting!(int, "foo bar") bar = 3;

     auto settings ()
     {
         return Tuple!(typeof(bar), "bar")(bar);
     }
}

void main ()
{
     auto a = new A;
     assert(a.bar.description == "foo bar");
     assert(a.bar.value == 3);
     assert(a.bar == 3);
     assert(a.settings.bar == 3);
}

In "settings" you should be able to:

1. Iterate over all fields of the type Setting using 
__tratis(derivedMembers)
2. Create and return tuple of all these fields

But then you won't be able to set the value via "settings".

Perhaps a variant is easier, but then you need to tell it what type to 
return, something like:

auto bar = a.settings["bar"].value!(int);

http://dlang.org/traits.html#derivedMembers

-- 
/Jacob Carlborg