Report a bug
If you spot a problem with this page, click here to create a GitHub issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signed-in GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
a local clone.
mir.ion.ser.json
High level JSON serialization API
- struct
JsonSerializer
(string sep, Appender); - JSON serialization back-end
- Appender*
appender
; - JSON string buffer
- size_t
objectBegin
();
voidobjectEnd
(size_tstate
);
size_tarrayBegin
();
voidarrayEnd
(size_tstate
);
voidputCompileTimeKey
(string key)();
voidputKey
(scope const char[]key
);
voidputValue
(Num)(const Numnum
)
if (isNumeric!Num && !is(Num == enum));
voidputValue
(size_t size)(auto ref const BigInt!sizenum
);
voidputValue
(size_t size)(auto ref const Decimal!sizenum
);
voidputValue
(typeof(null));
voidputValue
(boolb
);
voidputEscapedValue
(scope const char[]value
);
voidputValue
(scope const char[]value
);
voidelemBegin
(); - Serialization primitives
- string
serializeJson
(V)(auto ref Vvalue
); - JSON serialization function.Examples:
struct S { string foo; uint bar; } assert(serializeJson(S("str", 4)) == `{"foo":"str","bar":4}`);
Examples:import mir.serde: serdeIgnoreDefault; static struct Decor { int candles; // 0 float fluff = float.infinity; // inf } static struct Cake { @serdeIgnoreDefault string name = "Chocolate Cake"; int slices = 8; float flavor = 1; @serdeIgnoreDefault Decor dec = Decor(20); // { 20, inf } } assert(Cake("Normal Cake").serializeJson == `{"name":"Normal Cake","slices":8,"flavor":1.0}`); auto cake = Cake.init; cake.dec = Decor.init; assert(cake.serializeJson == `{"slices":8,"flavor":1.0,"dec":{"candles":0,"fluff":"inf"}}`); assert(cake.dec.serializeJson == `{"candles":0,"fluff":"inf"}`); static struct A { @serdeIgnoreDefault string str = "Banana"; int i = 1; } assert(A.init.serializeJson == `{"i":1}`); static struct S { @serdeIgnoreDefault A a; } assert(S.init.serializeJson == `{}`); assert(S(A("Berry")).serializeJson == `{"a":{"str":"Berry","i":1}}`); static struct D { S s; } assert(D.init.serializeJson == `{"s":{}}`); assert(D(S(A("Berry"))).serializeJson == `{"s":{"a":{"str":"Berry","i":1}}}`); assert(D(S(A(null, 0))).serializeJson == `{"s":{"a":{"str":null,"i":0}}}`); static struct F { D d; } assert(F.init.serializeJson == `{"d":{"s":{}}}`);
Examples:import mir.serde: serdeIgnoreIn; static struct S { @serdeIgnoreIn string s; } // assert(`{"s":"d"}`.deserializeJson!S.s == null, `{"s":"d"}`.deserializeJson!S.s); assert(S("d").serializeJson == `{"s":"d"}`);
Examples:import mir.ion.deser.json; static struct S { @serdeIgnoreOut string s; } assert(`{"s":"d"}`.deserializeJson!S.s == "d"); assert(S("d").serializeJson == `{}`);
Examples:import mir.serde: serdeIgnoreOutIf; static struct S { @serdeIgnoreOutIf!`a < 0` int a; } assert(serializeJson(S(3)) == `{"a":3}`, serializeJson(S(3))); assert(serializeJson(S(-3)) == `{}`);
Examples:import mir.rc.array; auto ar = rcarray!int(1, 2, 4); assert(ar.serializeJson == "[1,2,4]");
Examples:import std.range; import std.uuid; import mir.serde: serdeIgnoreOut, serdeLikeList, serdeProxy; static struct S { private int count; @serdeLikeList auto numbers() @property // uses `foreach` { return iota(count); } @serdeLikeList @serdeProxy!string // input element type of @serdeIgnoreOut Appender!(string[]) strings; //`put` method is used } assert(S(5).serializeJson == `{"numbers":[0,1,2,3,4]}`); // assert(`{"strings":["a","b"]}`.deserializeJson!S.strings.data == ["a","b"]);
Examples:import mir.serde: serdeLikeStruct, serdeProxy; static struct M { private int sum; // opApply is used for serialization int opApply(int delegate(scope const char[] key, ref const int val) pure dg) pure { { int var = 1; if (auto r = dg("a", var)) return r; } { int var = 2; if (auto r = dg("b", var)) return r; } { int var = 3; if (auto r = dg("c", var)) return r; } return 0; } // opIndexAssign for deserialization void opIndexAssign(int val, string key) pure { sum += val; } } static struct S { @serdeLikeStruct @serdeProxy!int M obj; } assert(S.init.serializeJson == `{"obj":{"a":1,"b":2,"c":3}}`); // assert(`{"obj":{"a":1,"b":2,"c":9}}`.deserializeJson!S.obj.sum == 12);
Examples:import mir.ion.deser.json; import std.range; import std.algorithm; import std.conv; static struct S { @serdeTransformIn!"a += 2" @serdeTransformOut!(a =>"str".repeat.take(a).joiner("_").to!string) int a; } auto s = deserializeJson!S(`{"a":3}`); assert(s.a == 5); assert(serializeJson(s) == `{"a":"str_str_str_str_str"}`);
- string
serializeJsonPretty
(string sep = "\x09", V)(auto ref Vvalue
); - JSON serialization function with pretty formatting.Examples:
static struct S { int a; } assert(S(4).serializeJsonPretty!" " == q{{ "a": 4 }});
- void
serializeJson
(Appender, V)(ref Appenderappender
, auto ref Vvalue
); - JSON serialization for custom outputt range.Examples:
import mir.appender: ScopedBuffer; ScopedBuffer!char buffer; static struct S { int a; } serializeJson(buffer, S(4)); assert(buffer.data == `{"a":4}`);
- template
serializeJsonPretty
(string sep = "\x09") - JSON serialization function with pretty formatting and custom output range.Examples:
import mir.appender: ScopedBuffer; ScopedBuffer!char buffer; static struct S { int a; } serializeJsonPretty!" "(buffer, S(4)); assert(buffer.data == `{ "a": 4 }`);
- void
serializeJsonPretty
(Appender, V)(ref Appenderappender
, auto ref Vvalue
)
if (isOutputRange!(Appender, const(char)[]));
- template
jsonSerializer
(string sep = "") - Creates JSON serialization back-end. Use sep equal to "\t" or " " for pretty formatting.Examples:
import mir.appender: ScopedBuffer; import mir.bignum.integer; ScopedBuffer!char buffer; auto ser = jsonSerializer((()@trusted=>&buffer)()); auto state0 = ser.objectBegin; ser.putKey("null"); ser.putValue(null); ser.putKey("array"); auto state1 = ser.arrayBegin(); ser.elemBegin; ser.putValue(null); ser.elemBegin; ser.putValue(123); ser.elemBegin; ser.putValue(12300000.123); ser.elemBegin; ser.putValue("\t"); ser.elemBegin; ser.putValue("\r"); ser.elemBegin; ser.putValue("\n"); ser.elemBegin; ser.putValue(BigInt!2(1234567890)); ser.arrayEnd(state1); ser.objectEnd(state0); assert(buffer.data == `{"null":null,"array":[null,123,1.2300000123e7,"\t","\r","\n",1234567890]}`);
Examples:import std.array; import mir.bignum.integer; auto app = appender!string; auto ser = jsonSerializer!" "(&app); auto state0 = ser.objectBegin; ser.putKey("null"); ser.putValue(null); ser.putKey("array"); auto state1 = ser.arrayBegin(); ser.elemBegin; ser.putValue(null); ser.elemBegin; ser.putValue(123); ser.elemBegin; ser.putValue(12300000.123); ser.elemBegin; ser.putValue("\t"); ser.elemBegin; ser.putValue("\r"); ser.elemBegin; ser.putValue("\n"); ser.elemBegin; ser.putValue(BigInt!2("1234567890")); ser.arrayEnd(state1); ser.objectEnd(state0); assert(app.data == `{ "null": null, "array": [ null, 123, 1.2300000123e7, "\t", "\r", "\n", 1234567890 ] }`);
- auto
jsonSerializer
(Appender)(return Appender*appender
);
Copyright © 2016-2021 by Ilya Yaroshenko | Page generated by
Ddoc on Tue Feb 23 12:40:47 2021