652 lines
19 KiB
D
652 lines
19 KiB
D
/**
|
|
* Algebraic data type implementation based on a tagged union.
|
|
*
|
|
* Copyright: Copyright 2015, Sönke Ludwig.
|
|
* License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
|
|
* Authors: Sönke Ludwig
|
|
*/
|
|
module taggedalgebraic;
|
|
|
|
import std.typetuple;
|
|
|
|
// TODO:
|
|
// - distinguish between @property and non@-property methods.
|
|
// - verify that static methods are handled properly
|
|
|
|
/** Implements a generic algebraic type using an enum to identify the stored type.
|
|
|
|
This struct takes a `union` or `struct` declaration as an input and builds
|
|
an algebraic data type from its fields, using an automatically generated
|
|
`Type` enumeration to identify which field of the union is currently used.
|
|
Multiple fields with the same value are supported.
|
|
|
|
All operators and methods are transparently forwarded to the contained
|
|
value. The caller has to make sure that the contained value supports the
|
|
requested operation. Failure to do so will result in an assertion failure.
|
|
|
|
The return value of forwarded operations is determined as follows:
|
|
$(UL
|
|
$(LI If the type can be uniquely determined, it is used as the return
|
|
value)
|
|
$(LI If there are multiple possible return values and all of them match
|
|
the unique types defined in the `TaggedAlgebraic`, a
|
|
`TaggedAlgebraic` is returned.)
|
|
$(LI If there are multiple return values and none of them is a
|
|
`Variant`, an `Algebraic` of the set of possible return types is
|
|
returned.)
|
|
$(LI If any of the possible operations returns a `Variant`, this is used
|
|
as the return value.)
|
|
)
|
|
*/
|
|
struct TaggedAlgebraic(U) if (is(U == union) || is(U == struct))
|
|
{
|
|
import std.algorithm : among;
|
|
import std.string : format;
|
|
import std.traits : CopyTypeQualifiers, FieldTypeTuple, FieldNameTuple, Largest, hasElaborateCopyConstructor, hasElaborateDestructor;
|
|
|
|
private alias FieldTypes = FieldTypeTuple!U;
|
|
private alias fieldNames = FieldNameTuple!U;
|
|
|
|
static assert(FieldTypes.length > 0, "The TaggedAlgebraic's union type must have at least one field.");
|
|
static assert(FieldTypes.length == fieldNames.length);
|
|
|
|
|
|
private {
|
|
void[Largest!FieldTypes.sizeof] m_data;
|
|
Type m_type;
|
|
}
|
|
|
|
/// A type enum that identifies the type of value currently stored.
|
|
alias Type = TypeEnum!U;
|
|
|
|
/// The type ID of the currently stored value.
|
|
@property Type typeID() const { return m_type; }
|
|
|
|
// constructors
|
|
//pragma(msg, generateConstructors!U());
|
|
mixin(generateConstructors!U);
|
|
|
|
// postblit constructor
|
|
static if (anySatisfy!(hasElaborateCopyConstructor, FieldTypes))
|
|
{
|
|
this(this)
|
|
{
|
|
switch (m_type) {
|
|
default: break;
|
|
foreach (i, tname; fieldNames) {
|
|
alias T = typeof(__traits(getMember, U, tname));
|
|
static if (hasElaborateCopyConstructor!T)
|
|
{
|
|
case __traits(getMember, Type, tname):
|
|
typeid(T).postblit(cast(void*)&trustedGet!tname());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// destructor
|
|
static if (anySatisfy!(hasElaborateDestructor, FieldTypes))
|
|
{
|
|
~this()
|
|
{
|
|
switch (m_type) {
|
|
default: break;
|
|
foreach (i, tname; fieldNames) {
|
|
alias T = typeof(__traits(getMember, U, tname));
|
|
static if (hasElaborateDestructor!T)
|
|
{
|
|
case __traits(getMember, Type, tname):
|
|
.destroy(trustedGet!tname);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Enables conversion or extraction of the stored value.
|
|
T opCast(T)() inout
|
|
{
|
|
import std.conv : to;
|
|
|
|
switch (m_type) {
|
|
default: assert(false, "Cannot cast a "~(cast(Type)m_type).to!string~" value to "~T.stringof);
|
|
foreach (i, FT; FieldTypes) {
|
|
static if (is(typeof(cast(T)trustedGet!(fieldNames[i])) == T)) {
|
|
case __traits(getMember, Type, fieldNames[i]):
|
|
return cast(T)trustedGet!(fieldNames[i]);
|
|
}
|
|
}
|
|
}
|
|
assert(false); // never reached
|
|
}
|
|
|
|
// NOTE: "this TA" is used here as the functional equivalent of inout,
|
|
// just that it generates one template instantiation per modifier
|
|
// combination, so that we can actually decide what to do for each
|
|
// case.
|
|
|
|
/// Enables the invocation of methods of the stored value.
|
|
auto opDispatch(string name, this TA, ARGS...)(auto ref ARGS args) if (hasOp!(TA, OpKind.method, name, ARGS)) { return implementOp!(OpKind.method, name)(this, args); }
|
|
/// Enables equality comparison with the stored value.
|
|
auto opEquals(T, this TA)(auto ref T other) if (hasOp!(TA, OpKind.binary, "==", T)) { return implementOp!(OpKind.binary, "==")(this, other); }
|
|
/// Enables relational comparisons with the stored value.
|
|
auto opCmp(T, this TA)(auto ref T other) if (hasOp!(TA, OpKind.binary, "<", T)) { assert(false, "TODO!"); }
|
|
/// Enables the use of unary operators with the stored value.
|
|
auto opUnary(string op, this TA)() if (hasOp!(TA, OpKind.unary, op)) { return implementOp!(OpKind.unary, op)(this); }
|
|
/// Enables the use of binary operators with the stored value.
|
|
auto opBinary(string op, T, this TA)(auto ref T other) inout if (hasOp!(TA, OpKind.binary, op, T)) { return implementOp!(OpKind.binary, op)(this, other); }
|
|
/// Enables operator assignments on the stored value.
|
|
auto opOpAssign(string op, T, this TA)(auto ref T other) if (hasOp!(TA, OpKind.binary, op~"=", T)) { return implementOp!(OpKind.binary, op~"=")(this, other); }
|
|
/// Enables indexing operations on the stored value.
|
|
auto opIndex(this TA, ARGS...)(auto ref ARGS args) if (hasOp!(TA, OpKind.index, null, ARGS)) { return implementOp!(OpKind.index, null)(this, args); }
|
|
/// Enables index assignments on the stored value.
|
|
auto opIndexAssign(this TA, ARGS...)(auto ref ARGS args) if (hasOp!(TA, OpKind.indexAssign, null, ARGS)) { return implementOp!(OpKind.indexAssign, null)(this, args); }
|
|
|
|
private template hasOp(TA, OpKind kind, string name, ARGS...)
|
|
{
|
|
alias UQ = CopyTypeQualifiers!(TA, U);
|
|
enum hasOp = .hasOp!(UQ, kind, name, ARGS);
|
|
}
|
|
|
|
private static auto implementOp(OpKind kind, string name, T, ARGS...)(ref T self, auto ref ARGS args)
|
|
{
|
|
import std.array : join;
|
|
import std.variant : Algebraic, Variant;
|
|
alias UQ = CopyTypeQualifiers!(T, U);
|
|
|
|
alias info = OpInfo!(UQ, kind, name, ARGS);
|
|
|
|
switch (self.m_type) {
|
|
default: assert(false, "Operator "~name~" ("~kind.stringof~") can only be used on values of the following types: "~[info.fields].join(", "));
|
|
foreach (i, f; info.fields) {
|
|
alias FT = FieldTypes[i];
|
|
case __traits(getMember, Type, f):
|
|
static if (NoDuplicates!(info.ReturnTypes).length == 1)
|
|
return info.perform(self.trustedGet!f, args);
|
|
else static if (allSatisfy!(isMatchingUniqueType!U, info.ReturnTypes))
|
|
return TaggedAlgebraic(info.perform(self.trustedGet!f, args));
|
|
else static if (allSatisfy!(isNoVariant, info.ReturnTypes))
|
|
return Algebraic!(NoDuplicates!(info.ReturnTypes))(info.perform(self.trustedGet!f, args));
|
|
else static if (is(FT == Variant))
|
|
return info.perform(self.trustedGet!f, args);
|
|
else
|
|
return Variant(info.perform(self.trustedGet!f, args));
|
|
}
|
|
}
|
|
|
|
assert(false); // never reached
|
|
}
|
|
|
|
private @trusted @property ref inout(typeof(__traits(getMember, U, f))) trustedGet(string f)() inout { return trustedGet!(inout(typeof(__traits(getMember, U, f)))); }
|
|
private @trusted @property ref inout(T) trustedGet(T)() inout { return *cast(inout(T)*)m_data.ptr; }
|
|
}
|
|
|
|
bool hasType(T, U)(in ref TaggedAlgebraic!U ta)
|
|
{
|
|
switch (ta.typeID) {
|
|
default: return false;
|
|
foreach (i, FT; ta.FieldTypes)
|
|
static if (is(FT == T)) {
|
|
case __traits(getMember, ta.Type, ta.fieldNames[i]):
|
|
return true;
|
|
}
|
|
}
|
|
assert(false); // never reached
|
|
}
|
|
|
|
ref inout(T) get(T, U)(ref inout(TaggedAlgebraic!U) ta)
|
|
{
|
|
assert(hasType!(T, U)(ta));
|
|
return ta.trustedGet!T;
|
|
}
|
|
|
|
|
|
/** Operators and methods of the contained type can be used transparently.
|
|
*/
|
|
@safe unittest {
|
|
static struct S {
|
|
int v;
|
|
int test() { return v / 2; }
|
|
}
|
|
|
|
static union Test {
|
|
typeof(null) null_;
|
|
int integer;
|
|
string text;
|
|
string[string] dictionary;
|
|
S custom;
|
|
}
|
|
|
|
alias TA = TaggedAlgebraic!Test;
|
|
|
|
TA ta;
|
|
assert(ta.typeID == TA.Type.null_);
|
|
|
|
ta = 12;
|
|
assert(ta.typeID == TA.Type.integer);
|
|
assert(ta == 12);
|
|
assert(cast(int)ta == 12);
|
|
assert(cast(short)ta == 12);
|
|
|
|
ta += 12;
|
|
assert(ta == 24);
|
|
|
|
ta = ["foo" : "bar"];
|
|
assert(ta.typeID == TA.Type.dictionary);
|
|
assert(ta["foo"] == "bar");
|
|
|
|
ta["foo"] = "baz";
|
|
assert(ta["foo"] == "baz");
|
|
|
|
ta = S(8);
|
|
assert(ta.test() == 4);
|
|
}
|
|
|
|
/** Multiple fields are allowed to have the same type, in which case the type
|
|
ID enum is used to disambiguate.
|
|
*/
|
|
@safe unittest {
|
|
static union Test {
|
|
typeof(null) null_;
|
|
int count;
|
|
int difference;
|
|
}
|
|
|
|
alias TA = TaggedAlgebraic!Test;
|
|
|
|
TA ta;
|
|
ta = TA(12, TA.Type.count);
|
|
assert(ta.typeID == TA.Type.count);
|
|
assert(ta == 12);
|
|
}
|
|
|
|
unittest {
|
|
// test proper type modifier support
|
|
static struct S {
|
|
void test() {}
|
|
void testI() immutable {}
|
|
void testC() const {}
|
|
void testS() shared {}
|
|
void testSC() shared const {}
|
|
}
|
|
static union U {
|
|
S s;
|
|
}
|
|
|
|
auto u = TaggedAlgebraic!U(S.init);
|
|
const uc = u;
|
|
immutable ui = cast(immutable)u;
|
|
//const shared usc = cast(shared)u;
|
|
//shared us = cast(shared)u;
|
|
|
|
static assert( is(typeof(u.test())));
|
|
static assert(!is(typeof(u.testI())));
|
|
static assert( is(typeof(u.testC())));
|
|
static assert(!is(typeof(u.testS())));
|
|
static assert(!is(typeof(u.testSC())));
|
|
|
|
static assert(!is(typeof(uc.test())));
|
|
static assert(!is(typeof(uc.testI())));
|
|
static assert( is(typeof(uc.testC())));
|
|
static assert(!is(typeof(uc.testS())));
|
|
static assert(!is(typeof(uc.testSC())));
|
|
|
|
static assert(!is(typeof(ui.test())));
|
|
static assert( is(typeof(ui.testI())));
|
|
static assert( is(typeof(ui.testC())));
|
|
static assert(!is(typeof(ui.testS())));
|
|
static assert( is(typeof(ui.testSC())));
|
|
|
|
/*static assert(!is(typeof(us.test())));
|
|
static assert(!is(typeof(us.testI())));
|
|
static assert(!is(typeof(us.testC())));
|
|
static assert( is(typeof(us.testS())));
|
|
static assert( is(typeof(us.testSC())));
|
|
|
|
static assert(!is(typeof(usc.test())));
|
|
static assert(!is(typeof(usc.testI())));
|
|
static assert(!is(typeof(usc.testC())));
|
|
static assert(!is(typeof(usc.testS())));
|
|
static assert( is(typeof(usc.testSC())));*/
|
|
}
|
|
|
|
unittest {
|
|
// test attributes on contained values
|
|
import std.typecons : Rebindable, rebindable;
|
|
|
|
class C {
|
|
void test() {}
|
|
void testC() const {}
|
|
void testI() immutable {}
|
|
}
|
|
union U {
|
|
Rebindable!(immutable(C)) c;
|
|
}
|
|
|
|
auto ta = TaggedAlgebraic!U(rebindable(new immutable C));
|
|
static assert(!is(typeof(ta.test())));
|
|
static assert( is(typeof(ta.testC())));
|
|
static assert( is(typeof(ta.testI())));
|
|
}
|
|
|
|
version (unittest) {
|
|
// test recursive definition using a wrapper dummy struct
|
|
// (needed to avoid "no size yet for forward reference" errors)
|
|
template ID(What) { alias ID = What; }
|
|
private struct _test_Wrapper {
|
|
TaggedAlgebraic!_test_U u;
|
|
alias u this;
|
|
this(ARGS...)(ARGS args) { u = TaggedAlgebraic!_test_U(args); }
|
|
}
|
|
private union _test_U {
|
|
_test_Wrapper[] children;
|
|
int value;
|
|
}
|
|
unittest {
|
|
alias TA = _test_Wrapper;
|
|
auto ta = TA(null);
|
|
ta ~= TA(0);
|
|
ta ~= TA(1);
|
|
ta ~= TA([TA(2)]);
|
|
assert(ta[0] == 0);
|
|
assert(ta[1] == 1);
|
|
assert(ta[2][0] == 2);
|
|
}
|
|
}
|
|
|
|
unittest { // postblit/destructor test
|
|
static struct S {
|
|
static int i = 0;
|
|
bool initialized = false;
|
|
this(bool) { initialized = true; i++; }
|
|
this(this) { if (initialized) i++; }
|
|
~this() { if (initialized) i--; }
|
|
}
|
|
|
|
static struct U {
|
|
S s;
|
|
int t;
|
|
}
|
|
alias TA = TaggedAlgebraic!U;
|
|
{
|
|
assert(S.i == 0);
|
|
auto ta = TA(S(true));
|
|
assert(S.i == 1);
|
|
{
|
|
auto tb = ta;
|
|
assert(S.i == 2);
|
|
ta = tb;
|
|
assert(S.i == 2);
|
|
ta = 1;
|
|
assert(S.i == 1);
|
|
ta = S(true);
|
|
assert(S.i == 2);
|
|
}
|
|
assert(S.i == 1);
|
|
}
|
|
assert(S.i == 0);
|
|
|
|
static struct U2 {
|
|
S a;
|
|
S b;
|
|
}
|
|
alias TA2 = TaggedAlgebraic!U2;
|
|
{
|
|
auto ta2 = TA2(S(true), TA2.Type.a);
|
|
assert(S.i == 1);
|
|
}
|
|
assert(S.i == 0);
|
|
}
|
|
|
|
/// Convenience type that can be used for union fields that have no value (`void` is not allowed).
|
|
struct Void {}
|
|
|
|
private enum hasOp(U, OpKind kind, string name, ARGS...) = TypeTuple!(OpInfo!(U, kind, name, ARGS).fields).length > 0;
|
|
|
|
unittest {
|
|
static struct S {
|
|
void m(int i) {}
|
|
bool opEquals(int i) { return true; }
|
|
bool opEquals(S s) { return true; }
|
|
}
|
|
|
|
static union U { int i; string s; S st; }
|
|
|
|
static assert(hasOp!(U, OpKind.binary, "+", int));
|
|
static assert(hasOp!(U, OpKind.binary, "~", string));
|
|
static assert(hasOp!(U, OpKind.binary, "==", int));
|
|
static assert(hasOp!(U, OpKind.binary, "==", string));
|
|
static assert(hasOp!(U, OpKind.binary, "==", int));
|
|
static assert(hasOp!(U, OpKind.binary, "==", S));
|
|
static assert(hasOp!(U, OpKind.method, "m", int));
|
|
static assert(hasOp!(U, OpKind.binary, "+=", int));
|
|
static assert(!hasOp!(U, OpKind.binary, "~", int));
|
|
static assert(!hasOp!(U, OpKind.binary, "~", int));
|
|
static assert(!hasOp!(U, OpKind.method, "m", string));
|
|
static assert(!hasOp!(U, OpKind.method, "m"));
|
|
static assert(!hasOp!(const(U), OpKind.binary, "+=", int));
|
|
static assert(!hasOp!(const(U), OpKind.method, "m", int));
|
|
}
|
|
|
|
|
|
private static auto performOp(U, OpKind kind, string name, T, ARGS...)(ref T value, /*auto ref*/ ARGS args)
|
|
{
|
|
static if (kind == OpKind.binary) return mixin("value "~name~" args[0]");
|
|
else static if (kind == OpKind.unary) return mixin("name "~value);
|
|
else static if (kind == OpKind.method) return __traits(getMember, value, name)(args);
|
|
else static if (kind == OpKind.index) return value[args];
|
|
else static if (kind == OpKind.indexAssign) return value[args[1 .. $]] = args[0];
|
|
else static assert(false, "Unsupported kind of operator: "~kind.stringof);
|
|
}
|
|
|
|
unittest {
|
|
union U { int i; string s; }
|
|
|
|
{ int v = 1; assert(performOp!(U, OpKind.binary, "+")(v, 3) == 4); }
|
|
{ string v = "foo"; assert(performOp!(U, OpKind.binary, "~")(v, "bar") == "foobar"); }
|
|
}
|
|
|
|
|
|
private template OpInfo(U, OpKind kind, string name, ARGS...)
|
|
{
|
|
import std.traits : FieldTypeTuple, FieldNameTuple, ReturnType;
|
|
|
|
alias FieldTypes = FieldTypeTuple!U;
|
|
alias fieldNames = FieldNameTuple!U;
|
|
|
|
template fieldsImpl(size_t i)
|
|
{
|
|
static if (i < FieldTypes.length) {
|
|
static if (is(typeof(&performOp!(U, kind, name, FieldTypes[i], ARGS)))) {
|
|
alias fieldsImpl = TypeTuple!(fieldNames[i], fieldsImpl!(i+1));
|
|
} else alias fieldsImpl = fieldsImpl!(i+1);
|
|
} else alias fieldsImpl = TypeTuple!();
|
|
}
|
|
alias fields = fieldsImpl!0;
|
|
|
|
template ReturnTypesImpl(size_t i) {
|
|
static if (i < FieldTypes.length) {
|
|
static if (is(typeof(&performOp!(U, kind, name, FieldTypes[i], ARGS)))) {
|
|
alias T = ReturnType!(performOp!(U, kind, name, FieldTypes[i], ARGS));
|
|
alias ReturnTypesImpl = TypeTuple!(T, ReturnTypesImpl!(i+1));
|
|
} else alias ReturnTypesImpl = ReturnTypesImpl!(i+1);
|
|
} else alias ReturnTypesImpl = TypeTuple!();
|
|
}
|
|
alias ReturnTypes = ReturnTypesImpl!0;
|
|
|
|
static auto perform(T)(ref T value, auto ref ARGS args) { return performOp!(U, kind, name)(value, args); }
|
|
}
|
|
|
|
private enum OpKind {
|
|
binary,
|
|
unary,
|
|
method,
|
|
index,
|
|
indexAssign
|
|
}
|
|
|
|
private template TypeEnum(U)
|
|
{
|
|
import std.array : join;
|
|
import std.traits : FieldNameTuple;
|
|
mixin("enum TypeEnum { " ~ [FieldNameTuple!U].join(", ") ~ " }");
|
|
}
|
|
|
|
private string generateConstructors(U)()
|
|
{
|
|
import std.algorithm : map;
|
|
import std.array : join;
|
|
import std.string : format;
|
|
import std.traits : FieldTypeTuple;
|
|
|
|
string ret;
|
|
|
|
// disable default construction if first type is not a null/Void type
|
|
static if (!is(FieldTypeTuple!U[0] == typeof(null)) && !is(FieldTypeTuple!U[0] == Void))
|
|
{
|
|
ret ~= q{
|
|
@disable this();
|
|
};
|
|
}
|
|
|
|
// normal type constructors
|
|
foreach (tname; UniqueTypeFields!U)
|
|
ret ~= q{
|
|
this(typeof(U.%s) value)
|
|
{
|
|
m_data.rawEmplace(value);
|
|
m_type = Type.%s;
|
|
}
|
|
|
|
void opAssign(typeof(U.%s) value)
|
|
{
|
|
if (m_type != Type.%s) {
|
|
// NOTE: destroy(this) doesn't work for some opDispatch-related reason
|
|
static if (is(typeof(&this.__xdtor)))
|
|
this.__xdtor();
|
|
m_data.rawEmplace(value);
|
|
} else {
|
|
trustedGet!"%s" = value;
|
|
}
|
|
m_type = Type.%s;
|
|
}
|
|
}.format(tname, tname, tname, tname, tname, tname);
|
|
|
|
// type constructors with explicit type tag
|
|
foreach (tname; AmbiguousTypeFields!U)
|
|
ret ~= q{
|
|
this(typeof(U.%s) value, Type type)
|
|
{
|
|
assert(type.among!(%s), format("Invalid type ID for type %%s: %%s", typeof(U.%s).stringof, type));
|
|
m_data.rawEmplace(value);
|
|
m_type = type;
|
|
}
|
|
}.format(tname, [SameTypeFields!(U, tname)].map!(f => "Type."~f).join(", "), tname);
|
|
|
|
return ret;
|
|
}
|
|
|
|
private template UniqueTypeFields(U) {
|
|
import std.traits : FieldTypeTuple, FieldNameTuple;
|
|
|
|
alias Types = FieldTypeTuple!U;
|
|
|
|
template impl(size_t i) {
|
|
static if (i < Types.length) {
|
|
enum name = FieldNameTuple!U[i];
|
|
alias T = Types[i];
|
|
static if (staticIndexOf!(T, Types) == i && staticIndexOf!(T, Types[i+1 .. $]) < 0)
|
|
alias impl = TypeTuple!(name, impl!(i+1));
|
|
else alias impl = TypeTuple!(impl!(i+1));
|
|
} else alias impl = TypeTuple!();
|
|
}
|
|
alias UniqueTypeFields = impl!0;
|
|
}
|
|
|
|
private template AmbiguousTypeFields(U) {
|
|
import std.traits : FieldTypeTuple, FieldNameTuple;
|
|
|
|
alias Types = FieldTypeTuple!U;
|
|
|
|
template impl(size_t i) {
|
|
static if (i < Types.length) {
|
|
enum name = FieldNameTuple!U[i];
|
|
alias T = Types[i];
|
|
static if (staticIndexOf!(T, Types) == i && staticIndexOf!(T, Types[i+1 .. $]) >= 0)
|
|
alias impl = TypeTuple!(name, impl!(i+1));
|
|
else alias impl = impl!(i+1);
|
|
} else alias impl = TypeTuple!();
|
|
}
|
|
alias AmbiguousTypeFields = impl!0;
|
|
}
|
|
|
|
unittest {
|
|
union U {
|
|
int a;
|
|
string b;
|
|
int c;
|
|
double d;
|
|
}
|
|
static assert([UniqueTypeFields!U] == ["b", "d"]);
|
|
static assert([AmbiguousTypeFields!U] == ["a"]);
|
|
}
|
|
|
|
private template SameTypeFields(U, string field) {
|
|
import std.traits : FieldTypeTuple, FieldNameTuple;
|
|
|
|
alias Types = FieldTypeTuple!U;
|
|
|
|
alias T = typeof(__traits(getMember, U, field));
|
|
template impl(size_t i) {
|
|
static if (i < Types.length) {
|
|
enum name = FieldNameTuple!U[i];
|
|
static if (is(Types[i] == T))
|
|
alias impl = TypeTuple!(name, impl!(i+1));
|
|
else alias impl = TypeTuple!(impl!(i+1));
|
|
} else alias impl = TypeTuple!();
|
|
}
|
|
alias SameTypeFields = impl!0;
|
|
}
|
|
|
|
private template MemberType(U) {
|
|
template MemberType(string name) {
|
|
alias MemberType = typeof(__traits(getMember, U, name));
|
|
}
|
|
}
|
|
|
|
private template isMatchingType(U) {
|
|
import std.traits : FieldTypeTuple;
|
|
enum isMatchingType(T) = staticIndexOf!(T, FieldTypeTuple!U) >= 0;
|
|
}
|
|
|
|
private template isMatchingUniqueType(U) {
|
|
import std.traits : FieldTypeTuple;
|
|
template isMatchingUniqueType(T) {
|
|
alias Types = FieldTypeTuple!U;
|
|
enum idx = staticIndexOf!(T, Types);
|
|
static if (idx < 0) enum isMatchingUniqueType = false;
|
|
else static if (staticIndexOf!(T, Types[idx+1 .. $]) >= 0) enum isMatchingUniqueType = false;
|
|
else enum isMatchingUniqueType = true;
|
|
}
|
|
}
|
|
|
|
private template isNoVariant(T) {
|
|
import std.variant : Variant;
|
|
enum isNoVariant = !is(T == Variant);
|
|
}
|
|
|
|
private void rawEmplace(T)(void[] dst, ref T src)
|
|
{
|
|
T* tdst = () @trusted { return cast(T*)dst.ptr; } ();
|
|
static if (is(T == class)) {
|
|
*tdst = src;
|
|
} else {
|
|
import std.conv : emplace;
|
|
emplace(tdst);
|
|
*tdst = src;
|
|
}
|
|
}
|