From de24bd3786441914c8071092274ac160cc2c02c3 Mon Sep 17 00:00:00 2001 From: Linnea Gräf Date: Thu, 14 Nov 2024 02:14:48 +0100 Subject: Add tests --- build.gradle.kts | 14 +- genrecord.ts | 80 +++++ .../java/moe/nea/jcp/gson/GsonListBuilder.java | 2 +- .../main/java/moe/nea/jcp/gson/GsonOperations.java | 4 +- .../test/java/moe/nea/jcp/gson/test/TestBasic.java | 95 ++++++ src/main/java/moe/nea/pcj/json/BasicCodecs.java | 4 - .../java/moe/nea/pcj/json/JsonLikeOperations.java | 2 +- src/main/java/moe/nea/pcj/json/ListBuilder.java | 4 +- src/main/java/moe/nea/pcj/json/RecordCodec.java | 31 +- src/main/java/moe/nea/pcj/json/RecordJoiners.java | 353 +++++++++++++++++++++ 10 files changed, 549 insertions(+), 40 deletions(-) create mode 100644 gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java create mode 100644 src/main/java/moe/nea/pcj/json/RecordJoiners.java diff --git a/build.gradle.kts b/build.gradle.kts index 07e279f..29f3043 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -12,7 +12,15 @@ allprojects { dependencies { api("org.jspecify:jspecify:1.0.0") } - -tasks.test { - useJUnitPlatform() +allprojects { + afterEvaluate { + if (project.plugins.hasPlugin(JavaBasePlugin::class.java)) + dependencies { + testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1") + testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1") + } + } + tasks.withType(Test::class) { + useJUnitPlatform() + } } \ No newline at end of file diff --git a/genrecord.ts b/genrecord.ts index e69de29..a700dc9 100644 --- a/genrecord.ts +++ b/genrecord.ts @@ -0,0 +1,80 @@ +#!/usr/bin/env node --experimental-strip-types +function typArgs(a: string[]): string { + if (a.length == 0) return "" + return "<" + a.join(", ") + ">" +} + +function argFor(va: string): string { + return va.replace("T", "arg") +} + +/* public static JsonCodec join( + RecordCodec arg1, + RecordCodec arg2, + Tuple.Func2 joiner + ) { + return new RecordCompleteCodec<>() { + + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg1.enc(data, ops), arg2.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg1, arg2) + .map(it -> it.dec(format, ops), it -> it.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } +*/ + +function genRecordJoiner(elements: number) { + if (!elements) return + const vars = [...new Array(elements)].map((_, idx) => "T" + idx) + console.log(`\tpublic static ${typArgs([...vars, 'O', 'Format'])} JsonCodec join(`) + for (let var1 of vars) { + console.log(`\t\tRecordCodec ${argFor(var1)},`) + } + console.log(`\t\tTuple.Func${elements}${typArgs(['O', ...vars])} joiner`) + console.log("\t) {") + console.log("\t\treturn new RecordCompleteCodec<>() {") + + console.log("\t\t\t@Override") + console.log("\t\t\tpublic Result encode(O data, JsonLikeOperations ops) {") + console.log(`\t\t\t\treturn Stream.of(${vars.map(it => argFor(it) + ".enc(data, ops)").join(", ")})`) + console.log(`\t\t\t\t\t.reduce(Result.ok(ops.createObject()), RecordCodec::merge)`) + console.log(`\t\t\t\t\t.map(RecordBuilder::complete);`) + console.log("\t\t\t}") + + console.log("\t\t\t@Override") + console.log("\t\t\tpublic Result decode(RecordView format, JsonLikeOperations ops) {") + console.log(`\t\t\t\treturn Tuple.Tuple${elements}.collect(new Tuple.Tuple${elements}${elements ? '<>' : ''}(${vars.map(it => argFor(it) + ".dec(format, ops)").join(", ")}))`) + console.log("\t\t\t\t\t.map(it -> it.applyTo(joiner));") + console.log("\t\t\t}") + + console.log("\t\t};") + console.log("\t}") +} + +function genRecords(maxI: number) { + console.log("// @gen" + "erated by genrecord.ts") + console.log("package moe.nea.pcj.json;") + console.log(` +import moe.nea.pcj.*; +import moe.nea.pcj.json.RecordCodec.*; +import java.util.stream.*;`) + console.log() + console.log("@SuppressWarnings(\"unused\")") + console.log("public class RecordJoiners {") + for (let i = 0; i < maxI; i++) { + genRecordJoiner(i) + } + console.log("}") +} + +genRecords(15) + diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java index d1a6302..5e37a87 100644 --- a/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java +++ b/gson/src/main/java/moe/nea/jcp/gson/GsonListBuilder.java @@ -4,7 +4,7 @@ import com.google.gson.JsonArray; import com.google.gson.JsonElement; import moe.nea.pcj.json.ListBuilder; -public class GsonListBuilder extends GsonListView implements ListBuilder { +public class GsonListBuilder extends GsonListView implements ListBuilder { public GsonListBuilder() { super(new JsonArray()); diff --git a/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java b/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java index 7957d05..344c9a5 100644 --- a/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java +++ b/gson/src/main/java/moe/nea/jcp/gson/GsonOperations.java @@ -16,6 +16,8 @@ import moe.nea.pcj.Unit; import moe.nea.pcj.json.UnexpectedJsonElement; public class GsonOperations implements JsonLikeOperations { + public static final GsonOperations INSTANCE = new GsonOperations(); + @Override public JsonElement createNull(Unit value) { return JsonNull.INSTANCE; @@ -80,7 +82,7 @@ public class GsonOperations implements JsonLikeOperations { } @Override - public ListBuilder createList() { + public ListBuilder createList() { return new GsonListBuilder(); } diff --git a/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java b/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java new file mode 100644 index 0000000..c0e42b6 --- /dev/null +++ b/gson/src/test/java/moe/nea/jcp/gson/test/TestBasic.java @@ -0,0 +1,95 @@ +package moe.nea.jcp.gson.test; + +import com.google.gson.JsonElement; +import com.google.gson.JsonNull; +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; +import moe.nea.jcp.gson.GsonCodecs; +import moe.nea.jcp.gson.GsonOperations; +import moe.nea.pcj.Decode; +import moe.nea.pcj.Result; +import moe.nea.pcj.json.JsonLikeError; +import moe.nea.pcj.json.JsonLikeOperations; +import moe.nea.pcj.json.MissingKey; +import moe.nea.pcj.json.RecordJoiners; +import moe.nea.pcj.json.UnexpectedJsonElement; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.stream.Collectors; + +public class TestBasic { + private void assertFail(Result result, JsonLikeError... expectedError) { + if (result.isOk()) + throw new AssertionError("Expected fail"); + Assertions.assertEquals( + Arrays.stream(expectedError).collect(Collectors.toSet()), + new HashSet<>(result.errors()) + ); + } + + private void assertSuccess(Result result, T expected) { + for (Object error : result.errors()) { + throw new AssertionError(error.toString()); + } + Assertions.assertEquals(expected, result.valueOrPartial().get()); + } + + Result decode(Decode, JsonLikeError> decode, JsonElement element) { + return Result.cast(decode.decode(element, GsonOperations.INSTANCE)); + } + + GsonCodecs codecs = GsonCodecs.INSTANCE; + + @Test + void testString() { + assertSuccess(decode(codecs.STRING, new JsonPrimitive("test")), "test"); + } + + @Test + void testInt() { + assertSuccess(decode(codecs.INTEGER, new JsonPrimitive(1000)), 1000); + assertFail(decode(codecs.INTEGER, new JsonPrimitive("hehehe")), + new UnexpectedJsonElement("number", mkPrim("hehehe"))); + assertFail(decode(codecs.INTEGER, new JsonPrimitive("1")), + new UnexpectedJsonElement("number", mkPrim("1"))); + } + + record TestObject( + String foo, + int bar + ) {} + + static JsonElement mkPrim(Object arg) { + if (arg instanceof JsonElement el) return el; + if (arg instanceof String str) return new JsonPrimitive(str); + if (arg instanceof Number num) return new JsonPrimitive(num); + if (arg == null) return JsonNull.INSTANCE; + if (arg instanceof Boolean b) return new JsonPrimitive(b); + throw new IllegalArgumentException("Cannot convert " + arg + " to json object"); + } + + static JsonObject mkJsonObject(Object... args) { + JsonObject obj = new JsonObject(); + for (int i = 0; i < args.length; i += 2) { + obj.add((String) args[i], mkPrim(args[i + 1])); + } + return obj; + } + + @Test + void testObject() { + var codec = RecordJoiners.join( + codecs.STRING.fieldOf("foo").withGetter(TestObject::foo), + codecs.INTEGER.fieldOf("bar").withGetter(TestObject::bar), + TestObject::new + ); + assertSuccess(decode(codec, mkJsonObject("foo", "fooValue", "bar", -10)), + new TestObject("fooValue", -10)); + assertFail(decode(codec, mkJsonObject("foo", "fooValue")), + new MissingKey("bar")); + } +} + diff --git a/src/main/java/moe/nea/pcj/json/BasicCodecs.java b/src/main/java/moe/nea/pcj/json/BasicCodecs.java index 8f957f9..565711d 100644 --- a/src/main/java/moe/nea/pcj/json/BasicCodecs.java +++ b/src/main/java/moe/nea/pcj/json/BasicCodecs.java @@ -44,8 +44,4 @@ public class BasicCodecs { return Result.ok(ops.createNumeric(data)); } }; - - public JsonCodec objectCodec() { - - } } \ No newline at end of file diff --git a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java index 7bb0162..ffefeda 100644 --- a/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java +++ b/src/main/java/moe/nea/pcj/json/JsonLikeOperations.java @@ -26,7 +26,7 @@ public interface JsonLikeOperations extends Operation { Result, ? extends JsonLikeError> getObject(Format format); - ListBuilder createList(); + ListBuilder createList(); Result, ? extends JsonLikeError> getList(Format format); } diff --git a/src/main/java/moe/nea/pcj/json/ListBuilder.java b/src/main/java/moe/nea/pcj/json/ListBuilder.java index c6e9220..fd2a407 100644 --- a/src/main/java/moe/nea/pcj/json/ListBuilder.java +++ b/src/main/java/moe/nea/pcj/json/ListBuilder.java @@ -1,7 +1,7 @@ package moe.nea.pcj.json; -public interface ListBuilder extends ListView { - Format complete(); +public interface ListBuilder extends ListView { + ElementFormat complete(); void add(ElementFormat value); diff --git a/src/main/java/moe/nea/pcj/json/RecordCodec.java b/src/main/java/moe/nea/pcj/json/RecordCodec.java index 7ba8815..cb6d696 100644 --- a/src/main/java/moe/nea/pcj/json/RecordCodec.java +++ b/src/main/java/moe/nea/pcj/json/RecordCodec.java @@ -1,26 +1,23 @@ package moe.nea.pcj.json; -import moe.nea.pcj.Codec; import moe.nea.pcj.Result; -import moe.nea.pcj.Tuple; import java.util.function.Function; -import java.util.stream.Stream; public record RecordCodec( MapCodec codec, Function getter ) { - private Result, JsonLikeError> enc(O data, JsonLikeOperations ops) { + Result, JsonLikeError> enc(O data, JsonLikeOperations ops) { return codec().encode(getter().apply(data), ops); } - private Result dec(RecordView data, JsonLikeOperations ops) { + Result dec(RecordView data, JsonLikeOperations ops) { return codec().decode(data, ops); } - private static Result, JsonLikeError> merge(Result, JsonLikeError> left, Result, JsonLikeError> right) { + static Result, JsonLikeError> merge(Result, JsonLikeError> left, Result, JsonLikeError> right) { return left.flatMap(l -> right.flatMap(l::mergeWith)); } @@ -34,26 +31,4 @@ public record RecordCodec( protected abstract Result decode(RecordView record, JsonLikeOperations ops); } - public static JsonCodec join( - RecordCodec arg1, - RecordCodec arg2, - Tuple.Func2 joiner - ) { - return new RecordCompleteCodec<>() { - - @Override - public Result encode(O data, JsonLikeOperations ops) { - return Stream.of(arg1.enc(data, ops), arg2.enc(data, ops)) - .reduce(Result.ok(ops.createObject()), RecordCodec::merge) - .map(RecordBuilder::complete); - } - - @Override - public Result decode(RecordView format, JsonLikeOperations ops) { - return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg1, arg2) - .map(it -> it.dec(format, ops), it -> it.dec(format, ops))) - .map(it -> it.applyTo(joiner)); - } - }; - } } diff --git a/src/main/java/moe/nea/pcj/json/RecordJoiners.java b/src/main/java/moe/nea/pcj/json/RecordJoiners.java new file mode 100644 index 0000000..3af622d --- /dev/null +++ b/src/main/java/moe/nea/pcj/json/RecordJoiners.java @@ -0,0 +1,353 @@ +// @generated by genrecord.ts +package moe.nea.pcj.json; + +import moe.nea.pcj.*; +import moe.nea.pcj.json.RecordCodec.*; +import java.util.stream.*; + +@SuppressWarnings("unused") +public class RecordJoiners { + public static JsonCodec join( + RecordCodec arg0, + Tuple.Func1 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple1.collect(new Tuple.Tuple1<>(arg0.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + Tuple.Func2 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple2.collect(new Tuple.Tuple2<>(arg0.dec(format, ops), arg1.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + Tuple.Func3 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple3.collect(new Tuple.Tuple3<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + Tuple.Func4 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple4.collect(new Tuple.Tuple4<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + Tuple.Func5 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple5.collect(new Tuple.Tuple5<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + Tuple.Func6 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple6.collect(new Tuple.Tuple6<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + Tuple.Func7 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple7.collect(new Tuple.Tuple7<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + Tuple.Func8 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple8.collect(new Tuple.Tuple8<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + Tuple.Func9 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple9.collect(new Tuple.Tuple9<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + RecordCodec arg9, + Tuple.Func10 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple10.collect(new Tuple.Tuple10<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + RecordCodec arg9, + RecordCodec arg10, + Tuple.Func11 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple11.collect(new Tuple.Tuple11<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + RecordCodec arg9, + RecordCodec arg10, + RecordCodec arg11, + Tuple.Func12 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple12.collect(new Tuple.Tuple12<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + RecordCodec arg9, + RecordCodec arg10, + RecordCodec arg11, + RecordCodec arg12, + Tuple.Func13 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple13.collect(new Tuple.Tuple13<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } + public static JsonCodec join( + RecordCodec arg0, + RecordCodec arg1, + RecordCodec arg2, + RecordCodec arg3, + RecordCodec arg4, + RecordCodec arg5, + RecordCodec arg6, + RecordCodec arg7, + RecordCodec arg8, + RecordCodec arg9, + RecordCodec arg10, + RecordCodec arg11, + RecordCodec arg12, + RecordCodec arg13, + Tuple.Func14 joiner + ) { + return new RecordCompleteCodec<>() { + @Override + public Result encode(O data, JsonLikeOperations ops) { + return Stream.of(arg0.enc(data, ops), arg1.enc(data, ops), arg2.enc(data, ops), arg3.enc(data, ops), arg4.enc(data, ops), arg5.enc(data, ops), arg6.enc(data, ops), arg7.enc(data, ops), arg8.enc(data, ops), arg9.enc(data, ops), arg10.enc(data, ops), arg11.enc(data, ops), arg12.enc(data, ops), arg13.enc(data, ops)) + .reduce(Result.ok(ops.createObject()), RecordCodec::merge) + .map(RecordBuilder::complete); + } + @Override + public Result decode(RecordView format, JsonLikeOperations ops) { + return Tuple.Tuple14.collect(new Tuple.Tuple14<>(arg0.dec(format, ops), arg1.dec(format, ops), arg2.dec(format, ops), arg3.dec(format, ops), arg4.dec(format, ops), arg5.dec(format, ops), arg6.dec(format, ops), arg7.dec(format, ops), arg8.dec(format, ops), arg9.dec(format, ops), arg10.dec(format, ops), arg11.dec(format, ops), arg12.dec(format, ops), arg13.dec(format, ops))) + .map(it -> it.applyTo(joiner)); + } + }; + } +} -- cgit