chore: rename attribute expression association

aaron-steinfeld · aaron-steinfeld · commit 7fea23a385b8 · 2022-01-09T10:25:50.000-05:00
diff --git a/hypertrace-core-graphql b/hypertrace-core-graphql
@@ -1 +1 @@
-Subproject commit 7be2e988f23284b99fcf9854245402e3b6bff635
+Subproject commit 43f084b878511945a90c64065ed8024124b62769
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java
@@ -129,7 +129,7 @@ private Single<Entity> convertEntity(
                         entityRequest
                             .resultSetRequest()
                             .idAttribute()
-                            .attributeExpression()
+                            .attributeExpressionAssociation()
                             .value())
                     .toString(),
                 entityRequest.entityType(),
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java
@@ -72,9 +72,9 @@ private Single<Filter> buildEntityTypeFilter(EdgeSetGroupRequest request) {
         .map(
             entityTypes ->
                 AttributeAssociation.<FilterArgument>of(
-                    request.neighborTypeAttribute().attributeExpression().attribute(),
+                    request.neighborTypeAttribute().attributeExpressionAssociation().attribute(),
                     new EntityNeighborTypeFilter(
-                        request.neighborTypeAttribute().attributeExpression().value(),
+                        request.neighborTypeAttribute().attributeExpressionAssociation().value(),
                         entityTypes)))
         .flatMap(filterAssociation -> this.filterConverter.convert(Set.of(filterAssociation)));
   }
diff --git a/hypertrace-graphql-explorer-schema/src/main/java/org/hypertrace/graphql/explorer/dao/GatewayServiceSelectionMapConverter.java b/hypertrace-graphql-explorer-schema/src/main/java/org/hypertrace/graphql/explorer/dao/GatewayServiceSelectionMapConverter.java
@@ -69,11 +69,14 @@ private Single<Entry<ExploreResultMapKey, Selection>> buildAttributeMapEntry(
     return this.valueConverter
         .convert(row.getColumnsOrThrow(attributeRequest.asMapKey()))
         .flatMap(
-            value -> this.buildSelection(attributeRequest.attributeExpression().attribute(), value))
+            value ->
+                this.buildSelection(
+                    attributeRequest.attributeExpressionAssociation().attribute(), value))
         .map(
             selection ->
                 Map.entry(
-                    ExploreResultMapKey.attribute(attributeRequest.attributeExpression().value()),
+                    ExploreResultMapKey.attribute(
+                        attributeRequest.attributeExpressionAssociation().value()),
                     selection));
   }
 
@@ -90,7 +93,8 @@ private Single<Entry<ExploreResultMapKey, Selection>> buildAggregationMapEntry(
         .convert(row.getColumnsOrThrow(aggregationRequest.alias()))
         .flatMap(
             value ->
-                this.buildSelection(aggregationRequest.attributeExpression().attribute(), value))
+                this.buildSelection(
+                    aggregationRequest.attributeExpressionAssociation().attribute(), value))
         .zipWith(
             this.aggregationTypeConverter.convert(aggregationRequest.aggregation()),
             (selection, aggregation) ->
diff --git a/hypertrace-graphql-explorer-schema/src/main/java/org/hypertrace/graphql/explorer/fetcher/ExploreResultMapKey.java b/hypertrace-graphql-explorer-schema/src/main/java/org/hypertrace/graphql/explorer/fetcher/ExploreResultMapKey.java
@@ -30,7 +30,7 @@ public static ExploreResultMapKey attribute(AttributeExpression attributeExpress
   public static ExploreResultMapKey forAggregationRequest(
       MetricAggregationRequest aggregationRequest, MetricAggregationType aggregationType) {
     return new ExploreResultMapKey(
-        aggregationRequest.attributeExpression().value(),
+        aggregationRequest.attributeExpressionAssociation().value(),
         aggregationType,
         aggregationRequest.arguments());
   }
diff --git a/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/AggregatableOrderByExpressionListConverter.java b/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/AggregatableOrderByExpressionListConverter.java
@@ -64,23 +64,23 @@ private Single<OrderByExpression> buildOrderByExpression(
 
   private Single<Expression> buildSelectionExpression(
       AttributeAssociation<AggregatableOrderArgument> orderArgument) {
-    AttributeAssociation<AttributeExpression> attributeExpression =
-        this.buildAttributeExpression(orderArgument);
+    AttributeAssociation<AttributeExpression> attributeExpressionAssociation =
+        this.buildAttributeExpressionAssociation(orderArgument);
     return Maybe.fromOptional(Optional.ofNullable(orderArgument.value().aggregation()))
         .flatMapSingle(this.aggregationTypeConverter::convert)
         .flatMapSingle(
             aggregationType ->
                 orderArgument.value().size() == null
                     ? this.metricAggregationExpressionConverter.convertForNoArgsOrAlias(
-                        attributeExpression, aggregationType)
+                        attributeExpressionAssociation, aggregationType)
                     : this.metricAggregationExpressionConverter.convertForArgsButNoAlias(
-                        attributeExpression,
+                        attributeExpressionAssociation,
                         aggregationType,
                         List.of(Objects.requireNonNull(orderArgument.value().size()))))
-        .switchIfEmpty(this.columnExpressionConverter.convert(attributeExpression));
+        .switchIfEmpty(this.columnExpressionConverter.convert(attributeExpressionAssociation));
   }
 
-  private AttributeAssociation<AttributeExpression> buildAttributeExpression(
+  private AttributeAssociation<AttributeExpression> buildAttributeExpressionAssociation(
       AttributeAssociation<AggregatableOrderArgument> orderArgumentAttributeAssociation) {
     return AttributeAssociation.of(
         orderArgumentAttributeAssociation.attribute(),
diff --git a/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricAggregationContainerMapConverter.java b/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricAggregationContainerMapConverter.java
@@ -36,7 +36,7 @@ public Single<Map<AttributeExpression, BaselinedMetricAggregationContainer>> con
       Map<String, AggregatedMetricValue> metricResponses) {
     return Observable.fromIterable(metricRequests)
         .distinct()
-        .groupBy(request -> request.attributeExpression().value())
+        .groupBy(request -> request.attributeExpressionAssociation().value())
         .flatMapSingle(requests -> this.buildMetricContainerEntry(requests, metricResponses))
         .collect(immutableMapEntryCollector());
   }
diff --git a/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricAggregationExpressionConverter.java b/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricAggregationExpressionConverter.java
@@ -45,39 +45,40 @@ public Single<Set<Expression>> convert(Collection<MetricAggregationRequest> metr
 
   Single<Expression> convert(MetricAggregationRequest metricAggregation, String alias) {
     return this.buildAggregationFunctionExpression(
-            metricAggregation.attributeExpression(),
+            metricAggregation.attributeExpressionAssociation(),
             metricAggregation.aggregation(),
             metricAggregation.arguments(),
             alias)
         .map(functionExpression -> Expression.newBuilder().setFunction(functionExpression).build());
   }
 
   Single<Expression> convertForNoArgsOrAlias(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType) {
-    return convertForArgsButNoAlias(attributeExpression, aggregationType, Collections.emptyList());
+    return convertForArgsButNoAlias(
+        attributeExpressionAssociation, aggregationType, Collections.emptyList());
   }
 
   Single<Expression> convertForArgsButNoAlias(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType,
       List<Object> arguments) {
     return this.buildAggregationFunctionExpression(
-            attributeExpression,
+            attributeExpressionAssociation,
             aggregationType,
             arguments,
             StringValue.getDefaultInstance().getValue())
         .map(functionExpression -> Expression.newBuilder().setFunction(functionExpression).build());
   }
 
   private Single<FunctionExpression> buildAggregationFunctionExpression(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType,
       List<Object> arguments,
       String alias) {
     return zip(
         functionTypeConverter.convert(aggregationType),
-        this.columnExpressionConverter.convert(attributeExpression),
+        this.columnExpressionConverter.convert(attributeExpressionAssociation),
         this.convertArguments(arguments),
         (functionType, columnExpression, argumentExpressionList) ->
             FunctionExpression.newBuilder()
diff --git a/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricContainerMapConverter.java b/hypertrace-graphql-gateway-service-metric-utils/src/main/java/org/hypertrace/graphql/utils/metrics/gateway/MetricContainerMapConverter.java
@@ -53,7 +53,7 @@ public Single<Map<AttributeExpression, MetricContainer>> convert(
       Collection<MetricRequest> metricRequests, Entity entity, BaselineEntity baselineEntity) {
     return Observable.fromIterable(metricRequests)
         .distinct()
-        .groupBy(request -> request.attributeExpression().value())
+        .groupBy(request -> request.attributeExpressionAssociation().value())
         .flatMapSingle(requests -> this.buildMetricContainerEntry(requests, entity, baselineEntity))
         .collect(immutableMapEntryCollector());
   }
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/DefaultMetricAggregationRequestBuilder.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/DefaultMetricAggregationRequestBuilder.java
@@ -53,15 +53,17 @@ class DefaultMetricAggregationRequestBuilder implements MetricAggregationRequest
 
   @Override
   public Observable<MetricAggregationRequest> build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       SelectedField metricAggregationContainerField) {
     return Observable.fromStream(
             this.selectionFinder.findSelections(
                 metricAggregationContainerField.getSelectionSet(),
                 SelectionQuery.builder()
                     .matchesPredicate(field -> this.getAggregationTypeForField(field).isPresent())
                     .build()))
-        .map(selectedField -> this.requestForAggregationField(attributeExpression, selectedField));
+        .map(
+            selectedField ->
+                this.requestForAggregationField(attributeExpressionAssociation, selectedField));
   }
 
   @Override
@@ -74,27 +76,28 @@ public Single<List<MetricAggregationRequest>> build(
   }
 
   public MetricAggregationRequest build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType,
       List<Object> arguments) {
-    return this.build(attributeExpression, aggregationType, arguments, false);
+    return this.build(attributeExpressionAssociation, aggregationType, arguments, false);
   }
 
   private MetricAggregationRequest build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType,
       List<Object> arguments,
       boolean baseline) {
     return new DefaultMetricAggregationRequest(
-        attributeExpression, aggregationType, arguments, baseline);
+        attributeExpressionAssociation, aggregationType, arguments, baseline);
   }
 
   private MetricAggregationRequest requestForAggregationField(
-      AttributeAssociation<AttributeExpression> attributeExpression, SelectedField field) {
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
+      SelectedField field) {
     AttributeModelMetricAggregationType aggregationType =
         this.getAggregationTypeForField(field).orElseThrow();
     return this.build(
-        attributeExpression,
+        attributeExpressionAssociation,
         aggregationType,
         this.getArgumentsForAggregation(aggregationType, field.getArguments()),
         this.selectionFinder
@@ -170,7 +173,7 @@ private Integer percentileSize(Map<String, Object> arguments) {
   @Value
   @Accessors(fluent = true)
   private static class DefaultMetricAggregationRequest implements MetricAggregationRequest {
-    AttributeAssociation<AttributeExpression> attributeExpression;
+    AttributeAssociation<AttributeExpression> attributeExpressionAssociation;
     AttributeModelMetricAggregationType aggregation;
     List<Object> arguments;
     boolean baseline;
@@ -179,7 +182,9 @@ private static class DefaultMetricAggregationRequest implements MetricAggregatio
     public String alias() {
       return String.format(
           "%s_%s_%s",
-          this.aggregation.name(), this.attributeExpression.attribute().id(), this.arguments);
+          this.aggregation.name(),
+          this.attributeExpressionAssociation.attribute().id(),
+          this.arguments);
     }
 
     @Override
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/DefaultMetricRequestBuilder.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/DefaultMetricRequestBuilder.java
@@ -39,29 +39,29 @@ public Single<List<MetricRequest>> build(
   }
 
   private Observable<MetricRequest> collectAggregationsAndSeries(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       SelectedField metricContainerField) {
     return Single.zip(
             this.aggregationRequestBuilder
-                .build(attributeExpression, metricContainerField)
+                .build(attributeExpressionAssociation, metricContainerField)
                 .collect(Collectors.toUnmodifiableList()),
             this.seriesRequestBuilder
-                .build(attributeExpression, metricContainerField)
+                .build(attributeExpressionAssociation, metricContainerField)
                 .collect(Collectors.toUnmodifiableList()),
             this.seriesRequestBuilder
-                .buildBaselineSeriesRequests(attributeExpression, metricContainerField)
+                .buildBaselineSeriesRequests(attributeExpressionAssociation, metricContainerField)
                 .collect(Collectors.toUnmodifiableList()),
             (aggList, seriesList, baselineSeriesList) ->
                 new DefaultMetricRequest(
-                    attributeExpression, aggList, seriesList, baselineSeriesList))
+                    attributeExpressionAssociation, aggList, seriesList, baselineSeriesList))
         .cast(MetricRequest.class)
         .toObservable();
   }
 
   @Value
   @Accessors(fluent = true)
   private static class DefaultMetricRequest implements MetricRequest {
-    AttributeAssociation<AttributeExpression> attributeExpression;
+    AttributeAssociation<AttributeExpression> attributeExpressionAssociation;
     List<MetricAggregationRequest> aggregationRequests;
     List<MetricSeriesRequest> seriesRequests;
     List<MetricSeriesRequest> baselineSeriesRequests;
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricAggregationRequest.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricAggregationRequest.java
@@ -7,7 +7,7 @@
 
 public interface MetricAggregationRequest {
 
-  AttributeAssociation<AttributeExpression> attributeExpression();
+  AttributeAssociation<AttributeExpression> attributeExpressionAssociation();
 
   AttributeModelMetricAggregationType aggregation();
 
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricAggregationRequestBuilder.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricAggregationRequestBuilder.java
@@ -12,7 +12,7 @@
 
 public interface MetricAggregationRequestBuilder {
   Observable<MetricAggregationRequest> build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       SelectedField metricAggregationContainerField);
 
   Single<List<MetricAggregationRequest>> build(
@@ -21,7 +21,7 @@ Single<List<MetricAggregationRequest>> build(
       Stream<SelectedField> metricQueryableFieldStream);
 
   MetricAggregationRequest build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       AttributeModelMetricAggregationType aggregationType,
       List<Object> arguments);
 }
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricRequest.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricRequest.java
@@ -5,7 +5,7 @@
 import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 
 public interface MetricRequest {
-  AttributeAssociation<AttributeExpression> attributeExpression();
+  AttributeAssociation<AttributeExpression> attributeExpressionAssociation();
 
   List<MetricAggregationRequest> aggregationRequests();
 
diff --git a/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricSeriesRequestBuilder.java b/hypertrace-graphql-metric-schema/src/main/java/org/hypertrace/graphql/metric/request/MetricSeriesRequestBuilder.java
@@ -36,30 +36,31 @@ class MetricSeriesRequestBuilder {
   }
 
   Observable<MetricSeriesRequest> build(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       SelectedField metricContainerField) {
     return Observable.fromStream(
             this.selectionFinder.findSelections(
                 metricContainerField.getSelectionSet(),
                 SelectionQuery.namedChild(METRIC_INTERVAL_CONTAINER_SERIES_KEY)))
-        .flatMap(field -> this.flattenAggregationsForSeries(attributeExpression, field));
+        .flatMap(field -> this.flattenAggregationsForSeries(attributeExpressionAssociation, field));
   }
 
   Observable<MetricSeriesRequest> buildBaselineSeriesRequests(
-      AttributeAssociation<AttributeExpression> attributeExpression,
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
       SelectedField metricContainerField) {
     return Observable.fromStream(
             this.selectionFinder.findSelections(
                 metricContainerField.getSelectionSet(),
                 SelectionQuery.namedChild(BASELINE_INTERVAL_CONTAINER_SERIES_KEY)))
-        .flatMap(field -> this.flattenAggregationsForSeries(attributeExpression, field));
+        .flatMap(field -> this.flattenAggregationsForSeries(attributeExpressionAssociation, field));
   }
 
   private Observable<MetricSeriesRequest> flattenAggregationsForSeries(
-      AttributeAssociation<AttributeExpression> attributeExpression, SelectedField seriesField) {
+      AttributeAssociation<AttributeExpression> attributeExpressionAssociation,
+      SelectedField seriesField) {
     Duration period = this.buildSeriesPeriod(seriesField);
     return this.aggregationRequestBuilder
-        .build(attributeExpression, seriesField)
+        .build(attributeExpressionAssociation, seriesField)
         .map(aggregation -> new DefaultMetricSeriesRequest(aggregation, period));
   }
 
diff --git a/hypertrace-graphql-spaces-schema/src/main/java/org/hypertrace/graphql/spaces/dao/ExplorerBackedSpacesDao.java b/hypertrace-graphql-spaces-schema/src/main/java/org/hypertrace/graphql/spaces/dao/ExplorerBackedSpacesDao.java
@@ -78,7 +78,7 @@ private Single<ExploreRequest> buildRequest(GraphQlRequestContext context) {
                     new FixedTimeRange(this.clock.instant()),
                     attributeRequest,
                     this.metricAggregationRequestBuilder.build(
-                        attributeRequest.attributeExpression(),
+                        attributeRequest.attributeExpressionAssociation(),
                         AttributeModelMetricAggregationType.COUNT,
                         emptyList())));
   }
@@ -170,7 +170,7 @@ private static class ActiveSpaceExploreRequest implements ExploreRequest {
       this.orderArguments =
           List.of(
               new SpaceExploreOrderArgument(
-                  Optional.of(spaceIdRequest.attributeExpression().attribute())));
+                  Optional.of(spaceIdRequest.attributeExpressionAssociation().attribute())));
       this.groupByAttributeRequests = Set.of(spaceIdRequest);
     }
   }
diff --git a/hypertrace-graphql-spaces-schema/src/test/java/org/hypertrace/graphql/spaces/dao/ExplorerBackedSpacesDaoTest.java b/hypertrace-graphql-spaces-schema/src/test/java/org/hypertrace/graphql/spaces/dao/ExplorerBackedSpacesDaoTest.java
@@ -68,7 +68,7 @@ void beforeEach() {
 
     AttributeAssociation<AttributeExpression> mockExpressionAssociation =
         AttributeAssociation.of(mockAttribute, spaceIdExpression);
-    when(this.mockSpaceAttributeRequest.attributeExpression())
+    when(this.mockSpaceAttributeRequest.attributeExpressionAssociation())
         .thenReturn(mockExpressionAssociation);
 
     when(this.mockAttributeRequestBuilder.buildForAttributeExpression(

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public static ExploreResultMapKey attribute(AttributeExpression attributeExpress`
`30`	`30`	`public static ExploreResultMapKey forAggregationRequest(`
`31`	`31`	`MetricAggregationRequest aggregationRequest, MetricAggregationType aggregationType) {`
`32`	`32`	`return new ExploreResultMapKey(`
`33`		`- aggregationRequest.attributeExpression().value(),`
	`33`	`+ aggregationRequest.attributeExpressionAssociation().value(),`
`34`	`34`	`aggregationType,`
`35`	`35`	`aggregationRequest.arguments());`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public Single<Map<AttributeExpression, BaselinedMetricAggregationContainer>> con`
`36`	`36`	`Map<String, AggregatedMetricValue> metricResponses) {`
`37`	`37`	`return Observable.fromIterable(metricRequests)`
`38`	`38`	`.distinct()`
`39`		`- .groupBy(request -> request.attributeExpression().value())`
	`39`	`+ .groupBy(request -> request.attributeExpressionAssociation().value())`
`40`	`40`	`.flatMapSingle(requests -> this.buildMetricContainerEntry(requests, metricResponses))`
`41`	`41`	`.collect(immutableMapEntryCollector());`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public Single<Map<AttributeExpression, MetricContainer>> convert(`
`53`	`53`	`Collection<MetricRequest> metricRequests, Entity entity, BaselineEntity baselineEntity) {`
`54`	`54`	`return Observable.fromIterable(metricRequests)`
`55`	`55`	`.distinct()`
`56`		`- .groupBy(request -> request.attributeExpression().value())`
	`56`	`+ .groupBy(request -> request.attributeExpressionAssociation().value())`
`57`	`57`	`.flatMapSingle(requests -> this.buildMetricContainerEntry(requests, entity, baselineEntity))`
`58`	`58`	`.collect(immutableMapEntryCollector());`
`59`	`59`	`}`