From 4c9e92624c53b96c10095782d2c7420e83429076 Mon Sep 17 00:00:00 2001 From: douira Date: Sun, 14 Aug 2022 15:18:19 +0200 Subject: [PATCH] further refactoring and grouped transformation test --- .../ast/transform/ASTTransformer.java | 11 ++- .../ast/transform/EnumASTTransformer.java | 14 ++-- .../ast/transform/SingleASTTransformer.java | 5 -- .../ast/transform/TriASTTransformer.java | 76 ++++++++++++++++++- .../ast/transform/TriFullTransformation.java | 10 +++ .../transform/TriRootOnlyTransformation.java | 9 +++ .../douira/glsl_transformer/util/Triple.java | 49 ++++++++++++ .../transform/GroupedASTTransformerTest.java | 33 ++++++-- .../TestWithGroupedASTTransformer.java | 17 ++++- 9 files changed, 199 insertions(+), 25 deletions(-) create mode 100644 glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java create mode 100644 glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java create mode 100644 glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/Triple.java diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java index f4fc864d..950eb384 100644 --- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/ASTTransformer.java @@ -13,6 +13,7 @@ public abstract class ASTTransformer extends ASTParser implements ParameterizedTransformer { private T jobParameters; + private PrintType defaultPrintType = PrintType.COMPACT; @Override public T getJobParameters() { @@ -24,10 +25,18 @@ public void setJobParameters(T parameters) { jobParameters = parameters; } + public PrintType getDefaultPrintType() { + return defaultPrintType; + } + public abstract V transform(PrintType printType, V str) throws RecognitionException; @Override public V transform(V str) throws RecognitionException { - return transform(PrintType.COMPACT, str); + return transform(getDefaultPrintType(), str); + } + + public V transform(PrintType printType, V str, T parameters) throws RecognitionException { + return withJobParameters(parameters, () -> transform(printType, str)); } } diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java index 0ebe4f0f..411af3d9 100644 --- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/EnumASTTransformer.java @@ -8,7 +8,6 @@ public class EnumASTTransformer> extends GroupedASTTransformer, EnumMap> { - public EnumASTTransformer(Consumer> transformation, Class enumClass) { super(transformation, () -> new EnumMap<>(enumClass), () -> new EnumMap<>(enumClass)); } @@ -18,12 +17,17 @@ public EnumASTTransformer(Class enumClass) { } @Override - public void setResultMapSupplier(Supplier> resultMapSupplier) { - throw new UnsupportedOperationException("The enum map suppliers may not be changed."); + public void setTuMapSupplier(Supplier> tuMapSupplier) { + throw new UnsupportedOperationException("The enum map suppliers may not be changed individually."); } @Override - public void setTuMapSupplier(Supplier> tuMapSupplier) { - throw new UnsupportedOperationException("The enum map suppliers may not be changed."); + public void setResultMapSupplier(Supplier> resultMapSupplier) { + throw new UnsupportedOperationException("The enum map suppliers may not be changed individually."); + } + + public void setEnumType(Class enumClass) { + super.setTuMapSupplier(() -> new EnumMap<>(enumClass)); + super.setResultMapSupplier(() -> new EnumMap<>(enumClass)); } } diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java index 7ffd69e6..283ced76 100644 --- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/SingleASTTransformer.java @@ -69,9 +69,4 @@ public String transform(PrintType printType, String str) throws RecognitionExcep transformation.accept(translationUnit); return ASTPrinter.print(printType, translationUnit); } - - public String transform( - PrintType printType, String str, T parameters) throws RecognitionException { - return withJobParameters(parameters, () -> transform(printType, str)); - } } diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java index 9553cd1a..b1806a95 100644 --- a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriASTTransformer.java @@ -8,7 +8,7 @@ import io.github.douira.glsl_transformer.ast.node.TranslationUnit; import io.github.douira.glsl_transformer.ast.print.PrintType; import io.github.douira.glsl_transformer.job_parameter.JobParameters; -import io.github.douira.glsl_transformer.util.TriConsumer; +import io.github.douira.glsl_transformer.util.*; public class TriASTTransformer> extends EnumASTTransformer { private final E aType, bType, cType; @@ -27,8 +27,6 @@ public TriASTTransformer( this.enumClass = enumClass; } - // TODO: add condensed version with consumers of 3, 4 and 5 parameters like in single AST transformer - public TriASTTransformer(Class enumClass, E aType, E bType, E cType) { super(enumClass); this.aType = aType; @@ -37,7 +35,64 @@ public TriASTTransformer(Class enumClass, E aType, E bType, E cType) { this.enumClass = enumClass; } - public EnumMap transformThree(PrintType printType, String a, String b, String c) + public TriASTTransformer( + TriConsumer transformation, + Class enumClass, + E aType, + E bType, + E cType) { + this(enumClass, aType, bType, cType); + setTransformation(transformation); + } + + public TriASTTransformer( + TriRootOnlyTransformation transformation, + Class enumClass, + E aType, + E bType, + E cType) { + this(enumClass, aType, bType, cType); + setTransformation(transformation); + } + + public TriASTTransformer( + TriFullTransformation transformation, + Class enumClass, + E aType, + E bType, + E cType) { + this(enumClass, aType, bType, cType); + setTransformation(transformation); + } + + public void setTransformation(TriConsumer transformation) { + super.setTransformation(map -> transformation.accept(map.get(aType), map.get(bType), map.get(cType))); + } + + public void setTransformation(TriRootOnlyTransformation transformation) { + super.setTransformation(map -> { + final var a = map.get(aType); + final var b = map.get(bType); + final var c = map.get(cType); + transformation.accept(a, b, c, a.getRoot(), b.getRoot(), c.getRoot()); + }); + } + + public void setTransformation(TriFullTransformation transformation) { + super.setTransformation(map -> { + final var a = map.get(aType); + final var b = map.get(bType); + final var c = map.get(cType); + transformation.accept(a, b, c, a.getRoot(), b.getRoot(), c.getRoot(), getJobParameters()); + }); + } + + @Override + public void setEnumType(Class enumClass) { + throw new UnsupportedOperationException("The tri enum map types may not be changed."); + } + + public EnumMap transform(PrintType printType, String a, String b, String c) throws RecognitionException { var items = new EnumMap(enumClass); items.put(aType, a); @@ -45,4 +100,17 @@ public EnumMap transformThree(PrintType printType, String a, String b items.put(cType, c); return transform(printType, items); } + + public EnumMap transform(String a, String b, String c) throws RecognitionException { + return transform(getDefaultPrintType(), a, b, c); + } + + public Triple transform(PrintType printType, Triple str) throws RecognitionException { + var result = transform(printType, str.a, str.b, str.c); + return new Triple<>(result.get(aType), result.get(bType), result.get(cType)); + } + + public Triple transform(Triple str) throws RecognitionException { + return transform(getDefaultPrintType(), str); + } } diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java new file mode 100644 index 00000000..0f50f8c7 --- /dev/null +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriFullTransformation.java @@ -0,0 +1,10 @@ +package io.github.douira.glsl_transformer.ast.transform; + +import io.github.douira.glsl_transformer.ast.node.basic.ASTNode; +import io.github.douira.glsl_transformer.ast.query.Root; +import io.github.douira.glsl_transformer.job_parameter.JobParameters; + +@FunctionalInterface +public interface TriFullTransformation { + void accept(A a, A b, A c, Root rootA, Root rootB, Root rootC, T jobParameters); +} diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java new file mode 100644 index 00000000..063a85de --- /dev/null +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/ast/transform/TriRootOnlyTransformation.java @@ -0,0 +1,9 @@ +package io.github.douira.glsl_transformer.ast.transform; + +import io.github.douira.glsl_transformer.ast.node.basic.ASTNode; +import io.github.douira.glsl_transformer.ast.query.Root; + +@FunctionalInterface +public interface TriRootOnlyTransformation { + void accept(A a, A b, A c, Root rootA, Root rootB, Root rootC); +} diff --git a/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/Triple.java b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/Triple.java new file mode 100644 index 00000000..4333c3da --- /dev/null +++ b/glsl-transformer/src/main/java/io/github/douira/glsl_transformer/util/Triple.java @@ -0,0 +1,49 @@ +package io.github.douira.glsl_transformer.util; + +public class Triple { + public final V a, b, c; + + public Triple(V a, V b, V c) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((a == null) ? 0 : a.hashCode()); + result = prime * result + ((b == null) ? 0 : b.hashCode()); + result = prime * result + ((c == null) ? 0 : c.hashCode()); + return result; + } + + @Override + @SuppressWarnings("unchecked") + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Triple other = (Triple) obj; + if (a == null) { + if (other.a != null) + return false; + } else if (!a.equals(other.a)) + return false; + if (b == null) { + if (other.b != null) + return false; + } else if (!b.equals(other.b)) + return false; + if (c == null) { + if (other.c != null) + return false; + } else if (!c.equals(other.c)) + return false; + return true; + } +} diff --git a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformerTest.java b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformerTest.java index 8af9ae47..f68735ea 100644 --- a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformerTest.java +++ b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/ast/transform/GroupedASTTransformerTest.java @@ -4,17 +4,34 @@ import org.junit.jupiter.api.Test; -import io.github.douira.glsl_transformer.ast.print.PrintType; +import io.github.douira.glsl_transformer.ast.node.expression.LiteralExpression; import io.github.douira.glsl_transformer.test_util.TestWithGroupedASTTransformer; public class GroupedASTTransformerTest extends TestWithGroupedASTTransformer { @Test - void testInsertion() { - // TODO: add tri ast transformer test - // p.setTransformation(translationUnit -> { - // translationUnit.children.add(index, p.parseExternalDeclaration( - // translationUnit, "int a;")); - // }); - // assertEquals(output, p.transform(PrintType.COMPACT, input)); + void testGroupedTransformation() { + p.setTransformation((a, b, c, rootA, rootB, rootC) -> { + var index = rootB.nodeIndex.getOne(LiteralExpression.class).getInteger(); + a.children.add((int) index, p.parseExternalDeclaration(a, "int z;")); + assertTrue(rootA.identifierIndex.has("z")); + + b.children.add(c.children.get(0)); + c.children.remove(0); + assertTrue(rootB.identifierIndex.has("bar")); + assertFalse(rootC.identifierIndex.has("bar")); + + var zou = c.children.get(0); + zou.detach(); + b.children.add(zou); + assertTrue(rootB.identifierIndex.has("zou")); + assertFalse(rootC.identifierIndex.has("zou")); + }); + assertTransform( + "int a; int z; int b; int c; ", + "int f = 1; int foo = bar; int foo = zou; ", + "", + "int a; int b; int c; ", + "int f = 1;", + "int foo = bar; int foo = zou;"); } } diff --git a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/test_util/TestWithGroupedASTTransformer.java b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/test_util/TestWithGroupedASTTransformer.java index 6aecaced..d7cfdb30 100644 --- a/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/test_util/TestWithGroupedASTTransformer.java +++ b/glsl-transformer/src/test/java/io/github/douira/glsl_transformer/test_util/TestWithGroupedASTTransformer.java @@ -8,7 +8,7 @@ import org.junit.jupiter.api.BeforeEach; import io.github.douira.glsl_transformer.ast.print.PrintType; -import io.github.douira.glsl_transformer.ast.transform.*; +import io.github.douira.glsl_transformer.ast.transform.TriASTTransformer; import io.github.douira.glsl_transformer.job_parameter.JobParameters; public class TestWithGroupedASTTransformer { @@ -30,6 +30,19 @@ public Map transform(Map str) throws RecognitionExce } public void assertTransform(Map expected, Map input) { - assertEquals(expected, p.transform(PrintType.COMPACT, input)); + var result = p.transform(PrintType.COMPACT, input); + assertEquals(expected.get(Part.A), result.get(Part.A)); + assertEquals(expected.get(Part.B), result.get(Part.B)); + assertEquals(expected.get(Part.C), result.get(Part.C)); + assertEquals(expected, result); + } + + public void assertTransform(String aExpected, String bExpected, String cExpected, String aInput, String bInput, + String cInput) { + var result = p.transform(PrintType.COMPACT, Map.of(Part.A, aInput, Part.B, bInput, Part.C, cInput)); + assertEquals(aExpected, result.get(Part.A)); + assertEquals(bExpected, result.get(Part.B)); + assertEquals(cExpected, result.get(Part.C)); + assertEquals(Map.of(Part.A, aExpected, Part.B, bExpected, Part.C, cExpected), result); } }