Biotronic 
Posted in reply to Profile Anaysis
| On Thursday, 26 January 2017 at 05:58:26 UTC, Profile Anaysis wrote:
> Since we do not have attributes for enums, I use _ in front of the names for meta values.
>
> I need to get the non-meta values for the enum so I can iterate over it and use it properly.
>
> enum myEnum
> {
> _Meta1 = 0,
> A,B,C,
> _Meta3 = 43,
> D = 3,
> }
>
> The num, for all practical purposes does not contain _Meta1, and_Meta3. But in code I use to!myEnum(intI) and having the meta values complicate things(simple shifting may or may not work).
>
> I also need to create array indexers based on myEnum that don't include the meta characters.
>
> What I do a lot is convert integers in to fields of the enum.
>
> If I do not include any Meta, then it is straight forward to!myEnum(i), but with them it is not, so doing things like
>
> int[myEnum] x;
>
> x[to!myEnum(i))] is difficult because the conversion will be invalid for meta. I'd have to do some work on i to get the 0-n representation to map properly in to the enum... basically avoiding the meta fields.
>
> This would all be solved with attributes for enums, but that, I suppose is a pipe dream.
>
> Any ideas how I can make this easy?
Like Stefan said, __traits(allMembers, myEnum) lets you iterate over the elements of the enum. For a to!myEnum that ignores _Meta fields, you could do something like this:
T toEnum(T)(int n) {
foreach (element; __traits(allMembers, myEnum)) {
static if (element[0] != '_') {
if (n == cast(int)__traits(getMember, myEnum, element))
return __traits(getMember, myEnum, element);
}
}
assert(false);
}
Looking at your code though, I wonder if the problem you want solved is a different one. Especially this part:
> I'd have to do some work on i to get the 0-n representation to map properly in to the enum... basically avoiding the meta fields.
If I understand you correctly, you want this:
enum myEnum
{
_Meta1 = 0,
A,B,C,
_Meta3 = 43,
D = 3,
}
to become this:
enum myEnum
{
A = 0,
B = 1,
C = 2,
D = 3
}
That's a taller order, especially given that the original is equivalent to this:
enum myEnum
{
A = 1,
B = 2,
C = 3,
D = 3
// And some meta members, but not relevant here.
}
One option would look somewhat like this:
alias myEnum = Enum!q{
_Meta1 = 0,
A, B, C,
_Meta2 = 43,
D
};
template Enum(string enumBody) {
mixin(generateEnum!enumBody);
}
string generateEnum(string enumBody)() {
import std.conv;
string result;
mixin("enum members {"~enumBody~"}");
foreach (element; __traits(allMembers, members)) {
if (element[0] != '_') {
result ~= element ~ ",";
}
}
return "@MetaData!\""~enumBody~"\" enum Enum {"~result~"}";
}
template MetaData(string enumBody) {
mixin(generateMeta!enumBody);
}
string generateMeta(string enumBody)() {
import std.conv;
string result;
mixin("enum members {"~enumBody~"}");
foreach (element; __traits(allMembers, members)) {
if (element[0] == '_') {
result ~= element ~ " = " ~ (cast(int)__traits(getMember, members, element)).to!string ~ ",";
}
}
return "enum MetaData {"~result~"}";
}
template meta(T) if (is(T == enum)) {
import std.typetuple;
alias meta = AliasSeq!(__traits(getAttributes, T))[0];
}
void main() {
import std.stdio;
import std.conv;
import std.typetuple;
writeln(myEnum.A, ": ", cast(int)myEnum.A);
writeln(myEnum.B, ": ", cast(int)myEnum.B);
writeln(myEnum.C, ": ", cast(int)myEnum.C);
writeln(myEnum.D, ": ", cast(int)myEnum.D);
writeln(meta!myEnum._Meta1, ":", cast(int)meta!myEnum._Meta1);
writeln(meta!myEnum._Meta2, ":", cast(int)meta!myEnum._Meta2);
}
This lets you define the enum with a somewhat familiar syntax:
alias myEnum = Enum!q{
_Meta1 = 0,
A, B, C,
_Meta2 = 43,
D
};
and generates from that the equivalent of this:
@myEnum_Meta
enum myEnum {
A, B, C, D
}
enum myEnum_Meta {
_Meta1 = 0,
_Meta2 = 43
}
|
Permalink
Reply
