Skip to content

Commit 01ac21b

Browse files
9il9il
committed
update mir.serde for enums
1 parent d59f9c1 commit 01ac21b

File tree

1 file changed

+71
-24
lines changed

1 file changed

+71
-24
lines changed

‎source/mir/serde.d‎

Lines changed: 71 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ module mir.serde;
1313

1414
import mir.functional: naryFun;
1515
import mir.reflection;
16-
import std.traits: TemplateArgsOf, EnumMembers, hasUDA;
16+
import std.traits: TemplateArgsOf, EnumMembers, hasUDA, isAggregateType;
1717

1818
version (D_Exceptions)
1919
{
@@ -139,7 +139,7 @@ private template serdeIsAnnotationMemberIn(T)
139139
template serdeGetAnnotationMembersIn(T)
140140
{
141141
import std.meta: aliasSeqOf, Filter;
142-
static if (isSomeStruct!T)
142+
static if (isAggregateType!T)
143143
enum string[] serdeGetAnnotationMembersIn = [Filter!(serdeIsAnnotationMemberIn!T, aliasSeqOf!(DeserializableMembers!T))];
144144
else
145145
enum string[] serdeGetAnnotationMembersIn = null;
@@ -180,7 +180,7 @@ private template serdeIsAnnotationMemberOut(T)
180180
template serdeGetAnnotationMembersOut(T)
181181
{
182182
import std.meta: aliasSeqOf, Filter;
183-
static if (isSomeStruct!T)
183+
static if (isAggregateType!T)
184184
enum string[] serdeGetAnnotationMembersOut = [Filter!(serdeIsAnnotationMemberOut!T, aliasSeqOf!(DeserializableMembers!T))];
185185
else
186186
enum string[] serdeGetAnnotationMembersOut = null;
@@ -226,7 +226,7 @@ struct serdeAlgebraicAnnotation
226226
+/
227227
template serdeHasAlgebraicAnnotation(T)
228228
{
229-
static if (isSomeStruct!T || is(T == enum))
229+
static if (isAggregateType!T || is(T == enum))
230230
{
231231
static if (hasUDA!(T, serdeAlgebraicAnnotation))
232232
{
@@ -986,7 +986,7 @@ template serdeGetFinalProxy(T)
986986
alias serdeGetFinalProxy = .serdeGetFinalProxy!(serdeGetProxy!T);
987987
}
988988
else
989-
static if (is(typeof(Timestamp(T.init))))
989+
static if (isAggregateType!T && is(typeof(Timestamp(T.init))))
990990
{
991991
alias serdeGetFinalProxy = string;
992992
}
@@ -1032,7 +1032,7 @@ template serdeGetFinalDeepProxy(T)
10321032
alias serdeGetFinalDeepProxy = .serdeGetFinalDeepProxy!(serdeGetProxy!T);
10331033
}
10341034
else
1035-
static if (is(typeof(Timestamp(T.init))))
1035+
static if (isAggregateType!T && is(typeof(Timestamp(T.init))))
10361036
{
10371037
alias serdeGetFinalDeepProxy = string;
10381038
}
@@ -1042,11 +1042,11 @@ template serdeGetFinalDeepProxy(T)
10421042
alias serdeGetFinalDeepProxy = .serdeGetFinalDeepProxy!(T.serdeKeysProxy);
10431043
}
10441044
else
1045-
static if (is(T == enum))
1046-
{
1047-
alias serdeGetFinalDeepProxy = typeof(null);
1048-
}
1049-
else
1045+
// static if (is(T == enum))
1046+
// {
1047+
// alias serdeGetFinalDeepProxy = typeof(null);
1048+
// }
1049+
// else
10501050
{
10511051
alias serdeGetFinalDeepProxy = T;
10521052
}
@@ -1061,7 +1061,7 @@ template serdeGetFinalDeepProxy(T)
10611061
alias serdeGetFinalDeepProxy = T;
10621062
}
10631063
else
1064-
static if (is(T == V[K], K, V))
1064+
static if (is(immutable T == immutable V[K], K, V))
10651065
{
10661066
alias E = Unqual!V;
10671067
static if (isAggregateType!E || is(E == enum))
@@ -1101,9 +1101,12 @@ template serdeFinalProxyDeserializableMembers(T)
11011101
{
11021102
import std.meta: Filter, aliasSeqOf;
11031103
alias P = serdeGetFinalProxy!T;
1104-
static if (isSomeStruct!P)
1104+
static if (isAggregateType!P || is(P == enum))
11051105
enum string[] serdeFinalProxyDeserializableMembers = [Filter!(serdeIsDeserializable!P, aliasSeqOf!(DeserializableMembers!P))];
11061106
else
1107+
// static if (is(P == enum))
1108+
// enum string[] serdeFinalProxyDeserializableMembers = serdeGetKeysIn!P;
1109+
// else
11071110
enum string[] serdeFinalProxyDeserializableMembers = null;
11081111
}
11091112

@@ -1137,9 +1140,12 @@ template serdeFinalDeepProxySerializableMembers(T)
11371140
import std.traits: isAggregateType;
11381141
import std.meta: Filter, aliasSeqOf;
11391142
alias P = serdeGetFinalDeepProxy!T;
1140-
static if (isSomeStruct!P)
1143+
static if (isAggregateType!P || is(P == enum))
11411144
enum string[] serdeFinalDeepProxySerializableMembers = [Filter!(serdeIsSerializable!P, aliasSeqOf!(SerializableMembers!P))];
11421145
else
1146+
// static if (is(P == enum))
1147+
// enum string[] serdeFinalDeepProxySerializableMembers = [serdeGetKeyOut!P];
1148+
// else
11431149
enum string[] serdeFinalDeepProxySerializableMembers = null;
11441150
}
11451151

@@ -1172,9 +1178,12 @@ template serdeFinalProxySerializableMembers(T)
11721178
{
11731179
import std.meta: Filter, aliasSeqOf;
11741180
alias P = serdeGetFinalProxy!T;
1175-
static if (isSomeStruct!P)
1181+
static if (isAggregateType!P || is(P == enum))
11761182
enum string[] serdeFinalProxySerializableMembers = [Filter!(serdeIsSerializable!P, aliasSeqOf!(SerializableMembers!P))];
11771183
else
1184+
// static if (is(P == enum))
1185+
// enum string[] serdeFinalProxySerializableMembers = [serdeGetKeyOut!P];
1186+
// else
11781187
enum string[] serdeFinalProxySerializableMembers = null;
11791188
}
11801189

@@ -1208,16 +1217,18 @@ template serdeFinalDeepProxyDeserializableMembers(T)
12081217
import std.traits: isAggregateType;
12091218
import std.meta: Filter, aliasSeqOf;
12101219
alias P = serdeGetFinalDeepProxy!T;
1211-
static if (isAggregateType!P)
1220+
static if (isAggregateType!P || is(P == enum))
12121221
enum string[] serdeFinalDeepProxyDeserializableMembers = [Filter!(serdeIsDeserializable!P, aliasSeqOf!(DeserializableMembers!P))];
12131222
else
1223+
// static if (is(P == enum))
1224+
// enum string[] serdeFinalDeepProxyDeserializableMembers = serdeGetKeysIn!P;
1225+
// else
12141226
enum string[] serdeFinalDeepProxyDeserializableMembers = null;
12151227
}
12161228

12171229
///
12181230
version(mir_test) unittest
12191231
{
1220-
12211232
static struct A
12221233
{
12231234
@serdeIgnore
@@ -1691,6 +1702,11 @@ private template serdeFinalDeepProxyDeserializableMemberKeys(T)
16911702
else
16921703
enum string[] serdeFinalDeepProxyDeserializableMemberKeys = [staticMap!(aliasSeqOf, staticMap!(serdeGetKeysIn2!T, aliasSeqOf!(serdeFinalDeepProxyDeserializableMembers!T)))];
16931704
}
1705+
else
1706+
static if (is(T == enum))
1707+
{
1708+
enum string[] serdeFinalDeepProxyDeserializableMemberKeys = enumAllKeysIn!T;
1709+
}
16941710
else
16951711
enum string[] serdeFinalDeepProxyDeserializableMemberKeys = null;
16961712
}
@@ -1714,13 +1730,18 @@ private template serdeFinalDeepProxySerializableMemberKeys(T)
17141730
else
17151731
enum string[] serdeFinalDeepProxySerializableMemberKeys = [staticMap!(aliasSeqOf, staticMap!(serdeGetKeyOut2!T, aliasSeqOf!(serdeFinalDeepProxySerializableMembers!T)))];
17161732
}
1733+
else
1734+
static if (is(T == enum))
1735+
{
1736+
enum string[] serdeFinalDeepProxySerializableMemberKeys = enumAllKeysOut!T;
1737+
}
17171738
else
17181739
enum string[] serdeFinalDeepProxySerializableMemberKeys = null;
17191740
}
17201741

17211742
private template serdeGetAlgebraicAnnotations(T)
17221743
{
1723-
static if (isSomeStruct!T || is(T == enum))
1744+
static if (isAggregateType!T || is(T == enum))
17241745
static if (hasUDA!(T, serdeAlgebraicAnnotation))
17251746
enum string[] serdeGetAlgebraicAnnotations = [getUDA!(T, serdeAlgebraicAnnotation).annotation];
17261747
else
@@ -1787,22 +1808,26 @@ version(mir_test) unittest
17871808
@serdeProxy!(B[])
17881809
static interface E { int f() @property; }
17891810

1811+
enum N { a, b }
1812+
17901813
static class D
17911814
{
17921815
C c;
17931816

17941817
@serdeProxy!(E[])
17951818
int d;
1819+
1820+
N e;
17961821
}
17971822

17981823
@serdeAlgebraicAnnotation("$F")
17991824
@serdeProxy!D
18001825
static struct F { int f; }
18011826

1802-
static assert (serdeGetSerializationKeysRecurse!F == ["c", "d", "g"]);
1827+
static assert (serdeGetSerializationKeysRecurse!F == ["a", "b", "c", "d", "e", "g"]);
18031828

18041829
import mir.algebraic;
1805-
static assert (serdeGetSerializationKeysRecurse!(Nullable!(F, int)) == ["c", "d", "g", "$F"]);
1830+
static assert (serdeGetSerializationKeysRecurse!(Nullable!(F, int)) == ["a", "b", "c", "d", "e", "g", "$F"]);
18061831
}
18071832

18081833
/++
@@ -1829,22 +1854,28 @@ version(mir_test) unittest
18291854
@serdeProxy!(B[])
18301855
static interface E { int f() @property; }
18311856

1857+
enum N { a, b }
1858+
18321859
static class D
18331860
{
18341861
C c;
18351862

18361863
@serdeProxy!(E[])
18371864
int d;
1865+
1866+
N e;
18381867
}
18391868

18401869
@serdeAlgebraicAnnotation("$F")
18411870
@serdeProxy!D
18421871
static struct F { int f; }
18431872

1844-
static assert (serdeGetDeserializationKeysRecurse!F == ["c", "d", "g"]);
1873+
static assert (serdeGetDeserializationKeysRecurse!N == ["a", "b"], serdeGetDeserializationKeysRecurse!N);
1874+
1875+
static assert (serdeGetDeserializationKeysRecurse!F == ["a", "b", "c", "d", "e", "g"]);
18451876

18461877
import mir.algebraic;
1847-
static assert (serdeGetDeserializationKeysRecurse!(Nullable!(F, int)) == ["c", "d", "g", "$F"]);
1878+
static assert (serdeGetDeserializationKeysRecurse!(Nullable!(F, int)) == ["a", "b", "c", "d", "e", "g", "$F"]);
18481879
}
18491880

18501881
/++
@@ -1883,7 +1914,7 @@ enum serdeAlphabetOut;
18831914
A dummy structure usefull $(LREF serdeOrderedIn) support.
18841915
+/
18851916
struct SerdeOrderedDummy(T, bool __optionalByDefault = false)
1886-
if (is(serdeGetFinalProxy!T == T) && isSomeStruct!T)
1917+
if (is(serdeGetFinalProxy!T == T) && isAggregateType!T)
18871918
{
18881919
import std.traits: hasUDA;
18891920

@@ -1918,7 +1949,7 @@ public:
19181949
mixin("@(__traits(getAttributes, T." ~ member ~ ")) serdeDeserializationMemberType!(T, `" ~ member ~ "`) " ~ member ~ ";");
19191950
}
19201951
else
1921-
static if (isSomeStruct!(typeof(__traits(getMember, T, member))))
1952+
static if (isAggregateType!(typeof(__traits(getMember, T, member))))
19221953
{
19231954
static if (hasUDA!(typeof(__traits(getMember, T, member)), serdeProxy))
19241955
{
@@ -2185,3 +2216,19 @@ char[] fastToUpperInPlace()(scope return char[] a)
21852216
e = e.fastToUpper;
21862217
return a;
21872218
}
2219+
2220+
template enumAllKeysIn(T)
2221+
if (is(T == enum))
2222+
{
2223+
import std.traits: EnumMembers;
2224+
import std.meta: staticMap, aliasSeqOf;
2225+
enum string[] enumAllKeysIn = [staticMap!(aliasSeqOf, staticMap!(.serdeGetKeysIn, EnumMembers!T))];
2226+
}
2227+
2228+
template enumAllKeysOut(T)
2229+
if (is(T == enum))
2230+
{
2231+
import std.traits: EnumMembers;
2232+
import std.meta: staticMap, aliasSeqOf;
2233+
enum string[] enumAllKeysOut = [staticMap!(.serdeGetKeyOut, EnumMembers!T)];
2234+
}

0 commit comments

Comments
 (0)