Use instanceof-pattern-matching and avoid additional casts.

michael-simons · meistermeier · commit bcf7e855e35a · 2022-01-13T08:48:06.000+01:00
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jNestedMapEntityWriter.java b/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jNestedMapEntityWriter.java
@@ -158,7 +158,7 @@ private void addRelations(Map<String, Object> sink, Neo4jPersistentEntity<?> ent
 			// Not using the Mapping support here so that we don't have to deal with the nested array lists.
 			Collection<?> unifiedView = Optional
 					.ofNullable(context.getValue())
-					.map(v -> v instanceof Collection ? (Collection<?>) v : Collections.singletonList(v))
+					.map(v -> v instanceof Collection col ? col : Collections.singletonList(v))
 					.orElseGet(Collections::emptyList);
 
 			if (property.isDynamicAssociation()) {
@@ -207,9 +207,8 @@ private void addRelations(Map<String, Object> sink, Neo4jPersistentEntity<?> ent
 
 	private Function<Map.Entry<?, ?>, Stream<? extends Map.Entry<?, ?>>> intoSingleCollectionEntries() {
 		return e -> {
-			if (e.getValue() instanceof Collection) {
-				return ((Collection<?>) e.getValue()).stream()
-						.map(v -> new AbstractMap.SimpleEntry<>(e.getKey(), v));
+			if (e.getValue() instanceof Collection<?> col) {
+				return col.stream().map(v -> new AbstractMap.SimpleEntry<>(e.getKey(), v));
 			} else {
 				return Stream.of(e);
 			}
@@ -218,8 +217,8 @@ private void addRelations(Map<String, Object> sink, Neo4jPersistentEntity<?> ent
 
 	private Function<Object, Stream<? extends Map.Entry<?, ?>>> intoSingleMapEntries() {
 		return e -> {
-			if (e instanceof Map) {
-				return ((Map<?, ?>) e).entrySet().stream();
+			if (e instanceof Map<?, ?> map) {
+				return map.entrySet().stream();
 			} else {
 				return Stream.of((Map.Entry<?, ?>) e);
 			}
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jQuerySupport.java b/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jQuerySupport.java
@@ -165,28 +165,28 @@ final Object convertParameter(Object parameter, @Nullable Neo4jPersistentPropert
 
 		if (parameter == null) {
 			return Values.NULL;
-		} else if (parameter instanceof Range) {
-			return convertRange((Range) parameter);
-		} else if (parameter instanceof Distance) {
-			return calculateDistanceInMeter((Distance) parameter);
-		} else if (parameter instanceof Circle) {
-			return convertCircle((Circle) parameter);
-		} else if (parameter instanceof Instant) {
-			return ((Instant) parameter).atOffset(ZoneOffset.UTC);
-		} else if (parameter instanceof Box) {
-			return convertBox((Box) parameter);
-		} else if (parameter instanceof BoundingBox) {
-			return convertBoundingBox((BoundingBox) parameter);
+		} else if (parameter instanceof Range v) {
+			return convertRange(v);
+		} else if (parameter instanceof Distance v) {
+			return calculateDistanceInMeter(v);
+		} else if (parameter instanceof Circle v) {
+			return convertCircle(v);
+		} else if (parameter instanceof Instant v) {
+			return v.atOffset(ZoneOffset.UTC);
+		} else if (parameter instanceof Box v) {
+			return convertBox(v);
+		} else if (parameter instanceof BoundingBox v) {
+			return convertBoundingBox(v);
 		}
 
-		if (parameter instanceof Collection) {
-			Class<?> type = TemplateSupport.findCommonElementType((Collection) parameter);
+		if (parameter instanceof Collection<?> col) {
+			Class<?> type = TemplateSupport.findCommonElementType(col);
 			if (type != null && mappingContext.hasPersistentEntityFor(type)) {
 
 				EntityWriter<Object, Map<String, Object>> objectMapEntityWriter = Neo4jNestedMapEntityWriter
 						.forContext(mappingContext);
 
-				return ((Collection<?>) parameter).stream().map(v -> {
+				return col.stream().map(v -> {
 					Map<String, Object> result = new HashMap<>();
 					objectMapEntityWriter.write(v, result);
 					return result;
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jSpelSupport.java b/src/main/java/org/springframework/data/neo4j/repository/query/Neo4jSpelSupport.java
@@ -62,10 +62,10 @@ public final class Neo4jSpelSupport {
 	public static LiteralReplacement orderBy(@Nullable Object arg) {
 
 		Sort sort = null;
-		if (arg instanceof Pageable) {
-			sort = ((Pageable) arg).getSort();
-		} else if (arg instanceof Sort) {
-			sort = (Sort) arg;
+		if (arg instanceof Pageable v) {
+			sort = v.getSort();
+		} else if (arg instanceof Sort v) {
+			sort = v;
 		} else if (arg != null) {
 			throw new IllegalArgumentException(arg.getClass() + " is not a valid order criteria.");
 		}
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/OptionalUnwrappingConverter.java b/src/main/java/org/springframework/data/neo4j/repository/query/OptionalUnwrappingConverter.java
@@ -30,8 +30,8 @@ enum OptionalUnwrappingConverter implements Converter<Object, Object> {
 
 	@Override
 	public Object convert(Object source) {
-		if (source instanceof Optional) {
-			return ((Optional<?>) source).orElse(null);
+		if (source instanceof Optional<?> v) {
+			return v.orElse(null);
 		}
 		return source;
 	}
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/QuerydslNeo4jPredicateExecutor.java b/src/main/java/org/springframework/data/neo4j/repository/query/QuerydslNeo4jPredicateExecutor.java
@@ -131,11 +131,11 @@ public boolean exists(Predicate predicate) {
 	@Override
 	public <S extends T, R> R findBy(Predicate predicate, Function<FetchableFluentQuery<S>, R> queryFunction) {
 
-		if (this.neo4jOperations instanceof FluentFindOperation) {
+		if (this.neo4jOperations instanceof FluentFindOperation ops) {
 			@SuppressWarnings("unchecked") // defaultResultType will be a supertype of S and at this stage, the same.
 			FetchableFluentQuery<S> fluentQuery =
 					(FetchableFluentQuery<S>) new FetchableFluentQueryByPredicate<>(predicate, metaData, metaData.getType(),
-							(FluentFindOperation) this.neo4jOperations, this::count, this::exists);
+							ops, this::count, this::exists);
 			return queryFunction.apply(fluentQuery);
 		}
 		throw new UnsupportedOperationException(
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/ReactiveQuerydslNeo4jPredicateExecutor.java b/src/main/java/org/springframework/data/neo4j/repository/query/ReactiveQuerydslNeo4jPredicateExecutor.java
@@ -130,10 +130,10 @@ public Mono<Boolean> exists(Predicate predicate) {
 	@Override
 	public <S extends T, R, P extends Publisher<R>> P findBy(Predicate predicate, Function<ReactiveFluentQuery<S>, P> queryFunction) {
 
-		if (this.neo4jOperations instanceof ReactiveFluentFindOperation) {
+		if (this.neo4jOperations instanceof ReactiveFluentFindOperation ops) {
 			@SuppressWarnings("unchecked") // defaultResultType will be a supertype of S and at this stage, the same.
 			ReactiveFluentQuery<S> fluentQuery = (ReactiveFluentQuery<S>) new ReactiveFluentQueryByPredicate<>(predicate, metaData, metaData.getType(),
-							(ReactiveFluentFindOperation) this.neo4jOperations, this::count, this::exists);
+							ops, this::count, this::exists);
 			return queryFunction.apply(fluentQuery);
 		}
 		throw new UnsupportedOperationException(
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/SimpleQueryByExampleExecutor.java b/src/main/java/org/springframework/data/neo4j/repository/query/SimpleQueryByExampleExecutor.java
@@ -112,9 +112,9 @@ public <S extends T> boolean exists(Example<S> example) {
 	@Override
 	public <S extends T, R> R findBy(Example<S> example, Function<FetchableFluentQuery<S>, R> queryFunction) {
 
-		if (this.neo4jOperations instanceof FluentFindOperation) {
+		if (this.neo4jOperations instanceof FluentFindOperation ops) {
 			FetchableFluentQuery<S> fluentQuery = new FetchableFluentQueryByExample<>(example, example.getProbeType(),
-					mappingContext, (FluentFindOperation) this.neo4jOperations, this::count, this::exists);
+					mappingContext, ops, this::count, this::exists);
 			return queryFunction.apply(fluentQuery);
 		}
 		throw new UnsupportedOperationException(
diff --git a/src/main/java/org/springframework/data/neo4j/repository/query/SimpleReactiveQueryByExampleExecutor.java b/src/main/java/org/springframework/data/neo4j/repository/query/SimpleReactiveQueryByExampleExecutor.java
@@ -96,9 +96,9 @@ public <S extends T> Mono<Boolean> exists(Example<S> example) {
 
 	@Override
 	public <S extends T, R, P extends Publisher<R>> P findBy(Example<S> example, Function<ReactiveFluentQuery<S>, P> queryFunction) {
-		if (this.neo4jOperations instanceof ReactiveFluentFindOperation) {
+		if (this.neo4jOperations instanceof ReactiveFluentFindOperation ops) {
 			ReactiveFluentQuery<S> fluentQuery = new ReactiveFluentQueryByExample<>(example, example.getProbeType(),
-					mappingContext, (ReactiveFluentFindOperation) this.neo4jOperations, this::count, this::exists);
+					mappingContext, ops, this::count, this::exists);
 			return queryFunction.apply(fluentQuery);
 		}
 		throw new UnsupportedOperationException(

Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ enum OptionalUnwrappingConverter implements Converter<Object, Object> {`
`30`	`30`
`31`	`31`	`@Override`
`32`	`32`	`public Object convert(Object source) {`
`33`		`- if (source instanceof Optional) {`
`34`		`- return ((Optional<?>) source).orElse(null);`
	`33`	`+ if (source instanceof Optional<?> v) {`
	`34`	`+ return v.orElse(null);`
`35`	`35`	`}`
`36`	`36`	`return source;`
`37`	`37`	`}`