From ed71fc5e989b1ddf7c265662f242ea61109ce553 Mon Sep 17 00:00:00 2001 From: Miroslav Pokorny Date: Wed, 6 Dec 2023 22:56:24 +1100 Subject: [PATCH] ExpressionFunction.mapParameterValues was mapParameter --- .../function/ExpressionFunction.java | 7 +++--- ...ressionFunctionParameterValuesMapper.java} | 16 +++++++------- .../function/ExpressionFunctionTesting.java | 4 ++-- ...ionFunctionParameterValuesMapperTest.java} | 22 +++++++++---------- 4 files changed, 25 insertions(+), 24 deletions(-) rename src/main/java/walkingkooka/tree/expression/function/{ExpressionFunctionParametersMapper.java => ExpressionFunctionParameterValuesMapper.java} (72%) rename src/test/java/walkingkooka/tree/expression/function/{ExpressionFunctionParametersMapperTest.java => ExpressionFunctionParameterValuesMapperTest.java} (78%) diff --git a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunction.java b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunction.java index 26576a9b..14313e2b 100644 --- a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunction.java +++ b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunction.java @@ -117,10 +117,11 @@ default void checkParameterCount(final List parameters) { Class returnType(); /** - * Returns a new {@link ExpressionFunction} that adds the parameter mapper before this namedFunction. + * Returns a new {@link ExpressionFunction} that adds the parameter mapper before this {@link ExpressionFunction#apply(Object, Object)} + * is called, but after parameter values are prepared. */ - default ExpressionFunction mapParameters(final BiFunction, C, List> mapper) { - return ExpressionFunctionParametersMapper.with(mapper, this); + default ExpressionFunction mapParameterValues(final BiFunction, C, List> mapper) { + return ExpressionFunctionParameterValuesMapper.with(mapper, this); } /** diff --git a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapper.java b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapper.java similarity index 72% rename from src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapper.java rename to src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapper.java index 17858777..3975b933 100644 --- a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapper.java +++ b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapper.java @@ -26,18 +26,18 @@ /** * Wraps an {@link ExpressionFunction} and applies a {@link java.util.function.Function} on the parameters before calling the wrapped {@link ExpressionFunction}. */ -final class ExpressionFunctionParametersMapper extends ExpressionFunctionParameters { +final class ExpressionFunctionParameterValuesMapper extends ExpressionFunctionParameters { - static ExpressionFunctionParametersMapper with(final BiFunction, C, List> mapper, - final ExpressionFunction function) { + static ExpressionFunctionParameterValuesMapper with(final BiFunction, C, List> mapper, + final ExpressionFunction function) { Objects.requireNonNull(mapper, "mapper"); checkFunction(function); - return new ExpressionFunctionParametersMapper<>(mapper, function); + return new ExpressionFunctionParameterValuesMapper<>(mapper, function); } - private ExpressionFunctionParametersMapper(final BiFunction, C, List> mapper, - final ExpressionFunction function) { + private ExpressionFunctionParameterValuesMapper(final BiFunction, C, List> mapper, + final ExpressionFunction function) { super(function); this.mapper = mapper; } @@ -58,10 +58,10 @@ public T apply(final List parameters, * Special cases that handles if the new mapper is equal to the current. */ @Override - public ExpressionFunction mapParameters(final BiFunction, C, List> mapper) { + public ExpressionFunction mapParameterValues(final BiFunction, C, List> mapper) { return this.mapper.equals(mapper) ? this : - ExpressionFunctionParametersMapper.with(mapper, this); + ExpressionFunctionParameterValuesMapper.with(mapper, this); } /** diff --git a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionTesting.java b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionTesting.java index 5e95a516..343fa852 100644 --- a/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionTesting.java +++ b/src/main/java/walkingkooka/tree/expression/function/ExpressionFunctionTesting.java @@ -182,11 +182,11 @@ default void testParametersFlattenMustBeVariable() { } @Test - default void testMapParametersWithNullFunction() { + default void testMapParameterValuesWithNullFunction() { assertThrows( NullPointerException.class, () -> this.createBiFunction() - .mapParameters(null) + .mapParameterValues(null) ); } diff --git a/src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapperTest.java b/src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapperTest.java similarity index 78% rename from src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapperTest.java rename to src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapperTest.java index 3de715a3..3f41c59a 100644 --- a/src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParametersMapperTest.java +++ b/src/test/java/walkingkooka/tree/expression/function/ExpressionFunctionParameterValuesMapperTest.java @@ -33,7 +33,7 @@ import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; -public final class ExpressionFunctionParametersMapperTest extends ExpressionFunctionTestCase, Object> { +public final class ExpressionFunctionParameterValuesMapperTest extends ExpressionFunctionTestCase, Object> { private final static BiFunction, ExpressionEvaluationContext, List> MAPPER = (p, c) -> p.stream() .map(pp -> pp.toString().toUpperCase()) @@ -74,12 +74,12 @@ public List> parameters(final int count) { @Test public void testWithNullMapperFails() { - assertThrows(NullPointerException.class, () -> ExpressionFunctionParametersMapper.with(null, FUNCTION)); + assertThrows(NullPointerException.class, () -> ExpressionFunctionParameterValuesMapper.with(null, FUNCTION)); } @Test public void testWithNullFunctionFails() { - assertThrows(NullPointerException.class, () -> ExpressionFunctionParametersMapper.with(MAPPER, null)); + assertThrows(NullPointerException.class, () -> ExpressionFunctionParameterValuesMapper.with(MAPPER, null)); } @Test @@ -96,18 +96,18 @@ public void testName() { @Test public void testMapSameFunction() { - final ExpressionFunctionParametersMapper function = this.createBiFunction(); - assertSame(function, function.mapParameters(MAPPER)); + final ExpressionFunctionParameterValuesMapper function = this.createBiFunction(); + assertSame(function, function.mapParameterValues(MAPPER)); } @Test public void testMapFunctionThenApply() { - final ExpressionFunctionParametersMapper function = this.createBiFunction(); + final ExpressionFunctionParameterValuesMapper function = this.createBiFunction(); final BiFunction, ExpressionEvaluationContext, List> mapper = (p, c) -> p.stream() .map(pp -> pp.toString() + "-a") .collect(Collectors.toList()); - final ExpressionFunctionParametersMapper function2 = Cast.to(function.mapParameters(mapper)); + final ExpressionFunctionParameterValuesMapper function2 = Cast.to(function.mapParameterValues(mapper)); assertNotSame(function, function2); this.applyAndCheck(function2, @@ -124,8 +124,8 @@ public void testToString() { // helpers.......................................................................................................... @Override - public ExpressionFunctionParametersMapper createBiFunction() { - return ExpressionFunctionParametersMapper.with(MAPPER, FUNCTION); + public ExpressionFunctionParameterValuesMapper createBiFunction() { + return ExpressionFunctionParameterValuesMapper.with(MAPPER, FUNCTION); } @Override @@ -134,7 +134,7 @@ public int minimumParameterCount() { } @Override - public Class> type() { - return Cast.to(ExpressionFunctionParametersMapper.class); + public Class> type() { + return Cast.to(ExpressionFunctionParameterValuesMapper.class); } }