Simpler method names

Author: s1ck

core/src/main/java/org/neo4j/gds/core/loading/CSRGraphStore.java

@@ -353,29 +353,29 @@ public boolean hasRelationshipType(RelationshipType relationshipType) {
     public long relationshipCount() {
         long sum = 0L;
         for (var relationship : relationships.values()) {
-            long elementCount = relationship.forwardTopology().elementCount();
+            long elementCount = relationship.topology().elementCount();
             sum += elementCount;
         }
         return sum;
     }
 
     @Override
     public long relationshipCount(RelationshipType relationshipType) {
-        return relationships.get(relationshipType).forwardTopology().elementCount();
+        return relationships.get(relationshipType).topology().elementCount();
     }
 
     @Override
     public boolean hasRelationshipProperty(RelationshipType relType, String propertyKey) {
         return Optional.ofNullable(relationships.get(relType))
-            .flatMap(SingleTypeRelationshipImportResult::forwardProperties)
+            .flatMap(SingleTypeRelationshipImportResult::properties)
             .map(propertyStore -> propertyStore.containsKey(propertyKey))
             .orElse(false);
     }
 
     @Override
     public ValueType relationshipPropertyType(String propertyKey) {
         return relationships.values().stream()
-            .flatMap(relationship -> relationship.forwardProperties().stream())
+            .flatMap(relationship -> relationship.properties().stream())
             .filter(propertyStore -> propertyStore.containsKey(propertyKey))
             .map(propertyStore -> propertyStore.get(propertyKey).valueType())
             .findFirst()
@@ -385,23 +385,23 @@ public ValueType relationshipPropertyType(String propertyKey) {
     @Override
     public Set<String> relationshipPropertyKeys() {
         return relationships.values().stream()
-            .flatMap(relationship -> relationship.forwardProperties().stream())
+            .flatMap(relationship -> relationship.properties().stream())
             .flatMap(propertyStore -> propertyStore.keySet().stream())
             .collect(Collectors.toSet());
     }
 
     @Override
     public Set<String> relationshipPropertyKeys(RelationshipType relationshipType) {
         return Optional.ofNullable(relationships.get(relationshipType))
-            .flatMap(SingleTypeRelationshipImportResult::forwardProperties)
+            .flatMap(SingleTypeRelationshipImportResult::properties)
             .map(RelationshipPropertyStore::keySet)
             .orElseGet(Set::of);
     }
 
     @Override
     public RelationshipProperty relationshipPropertyValues(RelationshipType relationshipType, String propertyKey) {
         return Optional.ofNullable(relationships.get(relationshipType))
-            .flatMap(SingleTypeRelationshipImportResult::forwardProperties)
+            .flatMap(SingleTypeRelationshipImportResult::properties)
             .map(propertyStore -> propertyStore.get(propertyKey))
             .orElseGet(() -> RelationshipPropertyStore.empty().get(propertyKey));
     }
@@ -416,8 +416,8 @@ public void addRelationshipType(
     ) {
         updateGraphStore(graphStore -> {
             graphStore.relationships.computeIfAbsent(relationshipType, __ -> {
-                var builder = ImmutableSingleTypeRelationshipImportResult.builder()
-                    .forwardTopology(relationships.topology())
+                var builder = SingleTypeRelationshipImportResult.builder()
+                    .topology(relationships.topology())
                     .direction(direction);
 
                 var relationshipSchemaEntry = schema()
@@ -440,7 +440,7 @@ public void addRelationshipType(
                             Aggregation.NONE
                         )).build();
 
-                    builder.forwardProperties(properties);
+                    builder.properties(properties);
 
                     var valueType = ValueTypes.fromNumberType(relationshipPropertyType.get());
                     relationshipSchemaEntry.addProperty(propertyKey, RelationshipPropertySchema.of(
@@ -464,8 +464,8 @@ public DeletionResult deleteRelationships(RelationshipType relationshipType) {
                 Optional.ofNullable(graphStore.relationships.remove(relationshipType))
                     .ifPresentOrElse(
                         relationship -> {
-                            builder.deletedRelationships(relationship.forwardTopology().elementCount());
-                            relationship.forwardProperties().ifPresent(properties -> {
+                            builder.deletedRelationships(relationship.topology().elementCount());
+                            relationship.properties().ifPresent(properties -> {
                                 properties
                                     .values()
                                     .forEach(property -> builder.putDeletedProperty(
@@ -510,7 +510,7 @@ public CSRGraph getUnion() {
             var relationship = entry.getValue();
 
             return relationship
-                .forwardProperties()
+                .properties()
                 .map(properties -> properties.keySet().stream().map(Optional::of))
                 .orElseGet(() -> Stream.of(Optional.empty()))
                 .map(propertyKey -> createGraph(nodeLabels(), relationshipType, propertyKey));
@@ -556,8 +556,8 @@ public CompositeRelationshipIterator getCompositeRelationshipIterator(
         }
 
         var relationship = relationships.get(relationshipType);
-        var adjacencyList = relationship.forwardTopology().adjacencyList();
-        var relationshipPropertyStore = relationship.forwardProperties().orElse(RelationshipPropertyStore.empty());
+        var adjacencyList = relationship.topology().adjacencyList();
+        var relationshipPropertyStore = relationship.properties().orElse(RelationshipPropertyStore.empty());
 
         var properties = propertyKeys.isEmpty()
             ? CSRCompositeRelationshipIterator.EMPTY_PROPERTIES
@@ -587,9 +587,9 @@ private void releaseInternals() {
             closeables.accept((AutoCloseable) this.nodes);
         }
         this.relationships.values().forEach(relationship -> {
-            closeables.add(relationship.forwardTopology().adjacencyList());
+            closeables.add(relationship.topology().adjacencyList());
             relationship
-                .forwardProperties()
+                .properties()
                 .stream()
                 .flatMap(properties -> properties.values().stream())
                 .forEach(property -> closeables.add(property.values().propertiesList()));
@@ -700,15 +700,15 @@ private CSRGraph createGraphFromRelationshipType(
 
         var relationship = relationships.get(relationshipType);
         var properties = maybeRelationshipProperty.map(propertyKey -> relationship
-            .forwardProperties()
+            .properties()
             .map(props -> props.get(propertyKey).values())
             .orElseThrow(() -> new IllegalArgumentException("Relationship property key not present in graph: " + propertyKey)));
 
         var initialGraph = HugeGraph.create(
             nodes,
             graphSchema,
             filteredNodeProperties,
-            relationship.forwardTopology(),
+            relationship.topology(),
             properties
         );
 

core/src/main/java/org/neo4j/gds/core/loading/CSRGraphStoreUtil.java

@@ -96,8 +96,8 @@ public static CSRGraphStore createFromGraph(
         var relationshipImportResult = RelationshipImportResult.builder().putImportResult(
             relationshipType,
             SingleTypeRelationshipImportResult.builder()
-                .forwardTopology(relationships.topology())
-                .forwardProperties(relationshipProperties)
+                .topology(relationships.topology())
+                .properties(relationshipProperties)
                 .build()
         ).build();
 
@@ -260,7 +260,7 @@ public static GraphSchema computeGraphSchema(
                 relationshipType,
                 singleTypeRelationshipImportResult.direction()
             );
-            singleTypeRelationshipImportResult.forwardProperties()
+            singleTypeRelationshipImportResult.properties()
                 .map(RelationshipPropertyStore::relationshipProperties)
                 .ifPresent(properties -> properties.forEach((propertyKey, propertyValues) -> relationshipSchema
                     .getOrCreateRelationshipType(

core/src/main/java/org/neo4j/gds/core/loading/RelationshipImportResult.java

@@ -61,8 +61,8 @@ static RelationshipImportResult of(
         topologies.forEach((relationshipType, topology) -> relationshipImportResultBuilder.putImportResult(
             relationshipType,
             SingleTypeRelationshipImportResult.builder()
-                .forwardTopology(topology)
-                .forwardProperties(Optional.ofNullable(properties.get(relationshipType)).filter(p -> !p.isEmpty()))
+                .topology(topology)
+                .properties(Optional.ofNullable(properties.get(relationshipType)).filter(p -> !p.isEmpty()))
                 .direction(directions.get(relationshipType))
                 .build()
         ));
@@ -101,8 +101,8 @@ static RelationshipImportResult of(Map<RelationshipTypeAndProjection, List<Relat
             relationshipImportResultBuilder.putImportResult(
                 relationshipType,
                 SingleTypeRelationshipImportResult.builder()
-                    .forwardTopology(topology)
-                    .forwardProperties(propertyStore)
+                    .topology(topology)
+                    .properties(propertyStore)
                     .direction(direction)
                     .build()
             );
@@ -146,13 +146,13 @@ static RelationshipImportResult of(Collection<SingleTypeRelationshipImporter.Sin
 
             var importResultBuilder = builders.computeIfAbsent(
                 importContext.relationshipType(),
-                relationshipType -> ImmutableSingleTypeRelationshipImportResult.builder().direction(direction)
+                relationshipType -> SingleTypeRelationshipImportResult.builder().direction(direction)
             );
 
             if (isInverseRelationship) {
                 importResultBuilder.inverseTopology(topology).inverseProperties(properties);
             } else {
-                importResultBuilder.forwardTopology(topology).forwardProperties(properties);
+                importResultBuilder.topology(topology).properties(properties);
             }
         });
 

core/src/main/java/org/neo4j/gds/core/loading/SingleTypeRelationshipImportResult.java

@@ -34,9 +34,9 @@ public interface SingleTypeRelationshipImportResult {
 
     // TODO: add RelationshipSchema
 
-    Relationships.Topology forwardTopology();
+    Relationships.Topology topology();
 
-    Optional<RelationshipPropertyStore> forwardProperties();
+    Optional<RelationshipPropertyStore> properties();
 
     Optional<Relationships.Topology> inverseTopology();
 

cypher-aggregation/src/main/java/org/neo4j/gds/projection/CypherAggregation.java

@@ -659,8 +659,8 @@ private void buildRelationshipsWithProperties(
                 relationshipImportResultBuilder.putImportResult(
                     relationshipType,
                     SingleTypeRelationshipImportResult.builder()
-                        .forwardTopology(topology)
-                        .forwardProperties(propertyStore)
+                        .topology(topology)
+                        .properties(propertyStore)
                         .build()
                 );
             });

test-utils/src/main/java/org/neo4j/gds/gdl/GdlFactory.java

@@ -204,7 +204,7 @@ protected GraphSchema computeGraphSchema(NodeImportResult nodeImportResult, Rela
                 relationshipType,
                 singleTypeRelationshipImportResult.direction()
             );
-            singleTypeRelationshipImportResult.forwardProperties()
+            singleTypeRelationshipImportResult.properties()
                 .map(RelationshipPropertyStore::relationshipProperties)
                 .ifPresent(properties -> properties.forEach((propertyKey, propertyValues) -> relationshipSchema
                     .getOrCreateRelationshipType(
@@ -261,8 +261,8 @@ public CSRGraphStore build() {
                 loadResult.relationshipType(),
                 SingleTypeRelationshipImportResult.builder()
                     .direction(Direction.fromOrientation(graphProjectConfig().orientation()))
-                    .forwardTopology(loadResult.topology())
-                    .forwardProperties(propertyStoreBuilder.build())
+                    .topology(loadResult.topology())
+                    .properties(propertyStoreBuilder.build())
                     .build()
             );
         });