Re: Getting only the data members of a type

[Ali Çehreli]

On 03/31/2012 09:09 PM, Artur Skawina wrote:
> On 03/31/12 21:09, Ali Çehreli wrote:
>> How can I determine just the data members of a struct or class, 
excluding the member functions? isCallable() comes short as member 
variable that have opCall() defined are also callable:
> [...]
>> Wait! I found a solution before sending this message. :P 
isIntegral() works:
>>
>>          if (isIntegral!(typeof(mixin("S." ~ member)))) {
>>
>> Now the output is:
>>
>>      i is a member function
>>      m is a member variable<-- good but dubious
>>    foo is a member variable
> [...]
>
> Don't forget about templates (appear as members too, but don't have a 
type).

I see. We can't even use isCallable or isIntegral with a template 
member. Assuming S has this member function template:

    void bar(T)()
    {}

Then we get the following error:

/usr/include/d/dmd/phobos/std/traits.d(3223): Error: (S).bar(T) has no value

I don't know a way of saying "if a template".

> This will print all fields of struct/class S:
>
>     enum s = cast(S*)null;
>     foreach (i, m; s.tupleof) {
>        enum name = S.tupleof[i].stringof[4..$];
>        alias typeof(m) type;
>        writef("(%s) %s\n", type.stringof, name);
>     }
>
> Real Programmers don't use std.traits. ;)
>
> artur

Your method works but needing to iterate on a struct variable by 
s.tupleof and having to use the struct type as S.tupleof in the loop 
body is strange.

Looks like S.tupleof[i].stringof is the answer for what I was looking for:

import std.stdio;
import std.traits;

struct M
{
    int i;

    this(int i)
    {
        this.i = i;
    }

    void opCall()
    {}
}

struct S
{
    int i;
    M m;

    void foo()
    {}

    void bar(T)()
    {}
}

void main()
{
    enum s = S(42, M(7));

    foreach (i, m; s.tupleof) {
        writefln("%s:", i);

        enum name = S.tupleof[i].stringof[4..$];
        alias typeof(m) type;
        writefln("  S.tupleof[i]: %s", S.tupleof[i].stringof);
        writefln("  (type) name : (%s) %s", type.stringof, name);

        writefln("  m           : %s", m);
        writefln("  m.stringof  : %s", m.stringof);
    }
}

The output:

0:
  S.tupleof[i]: (S).i
  (type) name : (int) i
  m           : 42
  m.stringof  : 42
1:
  S.tupleof[i]: (S).m
  (type) name : (M) m
  m           : M(7)
  m.stringof  : m

Ali