On 2013-07-11, 20:22, Namespace wrote:
What should he do?
As far as I can see he has 3 options:
1. An external file with the enum information. Both classes would import
it and could use the same enum. But he cannot change the API, so this is
no real option.
2. Change test1 into this:
----
void test1() {
B b = cast(B) this.a;
MyStaticClass.test2(b);
}
----
This works fine. But is it safe? And is it good style?
And how is this cast converted? Is it cheap?
3. Change test2 so that it accepts (even) (u)int. But then he lose the
Type safety.
Does anyone have any advice?
This might be an option:
version (unittest) {
enum A {
foo = 1,
bar = 2,
}
enum B {
foo = 1,
bar = 2,
}
enum C {
foo = 3,
bar = 4,
}
enum D {
baz,
qux,
}
}
template sameMembers(T, U) {
template sameValue(string member) {
enum sameValue = __traits(getMember, T, member) ==
__traits(getMember, U, member);
}
import std.typetuple : allSatisfy;
enum sameMembers =
sameMemberNames!(T,U) &&
allSatisfy!(sameValue, __traits(allMembers, T));
} unittest {
assert(sameMembers!(A,A));
assert(sameMembers!(A,B));
assert(sameMembers!(B,A));
assert(sameMembers!(B,B));
assert(!sameMembers!(A,C));
assert(!sameMembers!(B,C));
assert(!sameMembers!(C,A));
assert(!sameMembers!(C,B));
}
template sameMemberNames(T, U) {
template Has(Type) {
template Has(string member) {
enum Has = __traits(hasMember, Type, member);
}
}
import std.typetuple : allSatisfy;
enum sameMemberNames =
allSatisfy!(Has!T, __traits(allMembers, U)) &&
allSatisfy!(Has!U, __traits(allMembers, T));
} unittest {
assert(sameMemberNames!(A,A));
assert(sameMemberNames!(A,B));
assert(sameMemberNames!(A,C));
assert(sameMemberNames!(B,A));
assert(sameMemberNames!(B,B));
assert(sameMemberNames!(B,C));
assert(sameMemberNames!(C,A));
assert(sameMemberNames!(C,B));
assert(sameMemberNames!(C,C));
assert(sameMemberNames!(D,D));
assert(!sameMemberNames!(A,D));
assert(!sameMemberNames!(B,D));
assert(!sameMemberNames!(C,D));
assert(!sameMemberNames!(D,A));
assert(!sameMemberNames!(D,B));
assert(!sameMemberNames!(D,C));
}
T ConvertEnum(T,U)(U value) if (sameMembers!(T,U)) {
return cast(T)value;
}
T ConvertEnum(T,U)(U value) if (sameMemberNames!(T,U) &&
!sameMembers!(T,U)) {
final switch (value) {
foreach (e; __traits(allMembers, U)) {
case __traits(getMember, U, e):
return __traits(getMember, T, e);
}
}
assert(false);
} unittest {
assert(ConvertEnum!A(B.foo) == A.foo);
assert(ConvertEnum!A(B.bar) == A.bar);
assert(ConvertEnum!A(C.foo) == A.foo);
assert(ConvertEnum!A(C.bar) == A.bar);
assert(ConvertEnum!B(A.foo) == B.foo);
assert(ConvertEnum!B(A.bar) == B.bar);
assert(ConvertEnum!B(C.foo) == B.foo);
assert(ConvertEnum!B(C.bar) == B.bar);
assert(ConvertEnum!C(A.foo) == C.foo);
assert(ConvertEnum!C(A.bar) == C.bar);
assert(ConvertEnum!C(B.foo) == C.foo);
assert(ConvertEnum!C(B.bar) == C.bar);
assert(!__traits(compiles, { auto tmp = ConvertEnum!D(A.foo); }));
assert(!__traits(compiles, { auto tmp = ConvertEnum!D(B.foo); }));
assert(!__traits(compiles, { auto tmp = ConvertEnum!D(C.foo); }));
assert(!__traits(compiles, { auto tmp = ConvertEnum!A(D.foo); }));
assert(!__traits(compiles, { auto tmp = ConvertEnum!B(D.foo); }));
assert(!__traits(compiles, { auto tmp = ConvertEnum!C(D.foo); }));
}
The function ConvertEnum safely converts from one enum to another, given
that the same members exist in both. If the enums are equal (same values
for
each member), a simple cast is used. If the names are equal, but values are
different, a switch/case is built, and A.Foo is converted to B.Foo.
--
Simen
