template UDA

[bitwise via Digitalmars-d]

On Monday, 7 September 2015 at 22:03:13 UTC, Adam D. Ruppe wrote:
> On Monday, 7 September 2015 at 22:00:07 UTC, bitwise wrote:
>> Is there any real(and plausible) use case where providing a 
>> template with no argument as a UDA would be useful?
>
> Yes, you actually wrote it yourself!
>
>> @MyAttribute!SomeClass class SomeClass { }
>
> That right there is a reason. When you are looking for UDAs, 
> you look for declarations. The usage code looks like:
>


I kinda understand what you're saying, but I still don't think 
there is any benefit to tagging something with a template which 
has no type. The attribute in the above example doesn't need to 
be a template.

I imagine that if I were to search for a template UDA, the next 
step would probably be to enumerate the template parameters and 
take special action. Otherwise, the type is not needed. I suppose 
a template UDA could either have some args, or no args, but I 
can't imaging a use case where this would actually happen.

> foreach(member; getMembers!module)
>   if(member.hasUDA!(MyAttribute)) {
>       // do something
>   }
>
> The beauty of it is that member is right there! So your 
> reflection code could instantiate it right there:
>
>   // do something becomes...
>   MyAttribute!(member);
>
> so it instantiates the template with the given member in the 
> reflection code itself.

My goal is not to have this reflection code at all(the loop which 
looks through the module instantiating things). I want the 
attribute itself to do that.

Example:

struct Reflection {
     string typeName;
     string[] members;

     static Reflection[string] reflections;
}

struct Reflected(T)
{
     static this() {
         string[] members;

         foreach(memberName; __traits(allMembers, T))
         {
             members ~= memberName;
         }

         enum typeName = fullyQualifiedName!T.stringof[1..$-1];

         writeln("registering type: " ~ typeName);
         Reflection.reflections[typeName] = Reflection(typeName, 
members);
     }
}

Reflection* reflect(Object obj) {
     writeln("retrieving type for: " ~ typeid(obj).toString);
     return typeid(obj).toString in Reflection.reflections;
}

@Reflected!A class A {
     int x;
     float y;
     string z;
}

void main(string[] args)
{
     A a = new A();

     foreach(n; a.reflect.members)
         writeln(n);
}



But I would like to have the attribute pick up the type that's 
attached.

I saw an example, in another post that went something like this:

struct MyAttribute(T = _UDA_OBJECT_) { }

This would be acceptable too, but for some reason, the response 
received almost no attention.

    Bit