[dbs-leipzig#1559] reformat code according code style

gradoop-temporal/src/main/java/org/gradoop/temporal/model/impl/operators/metric/AvgDegreeEvolution.java

@@ -23,7 +23,12 @@
 import org.gradoop.flink.model.impl.operators.sampling.functions.VertexDegree;
 import org.gradoop.temporal.model.api.TimeDimension;
 import org.gradoop.temporal.model.impl.TemporalGraph;
-import org.gradoop.temporal.model.impl.operators.metric.functions.*;
+import org.gradoop.temporal.model.impl.operators.metric.functions.GroupDegreeTreesToAggregateDegrees;
+import org.gradoop.temporal.model.impl.operators.metric.functions.TransformDeltaToAbsoluteDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.FlatMapVertexIdEdgeInterval;
+import org.gradoop.temporal.model.impl.operators.metric.functions.BuildTemporalDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.ExtractAllTimePointsReduce;
+import org.gradoop.temporal.model.impl.operators.metric.functions.AggregateType;
 
 import java.util.Objects;
 import java.util.TreeMap;
@@ -33,48 +38,50 @@
  * whole lifetime of the graph. The average value is rounded up to the next integer.
  */
 public class AvgDegreeEvolution
-        implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
-    /**
-     * The time dimension that will be considered.
-     */
-    private final TimeDimension dimension;
+    implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
+  /**
+   * The time dimension that will be considered.
+   */
+  private final TimeDimension dimension;
 
-    /**
-     * The degree type (IN, OUT, BOTH);
-     */
-    private final VertexDegree degreeType;
+  /**
+   * The degree type (IN, OUT, BOTH);
+   */
+  private final VertexDegree degreeType;
 
-    /**
-     * Creates an instance of this average degree evolution operator.
-     *
-     * @param degreeType the degree type to use (IN, OUT, BOTH).
-     * @param dimension the time dimension to use (VALID_TIME, TRANSACTION_TIME).
-     */
-    public AvgDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException{
-        this.degreeType = Objects.requireNonNull(degreeType);
-        this.dimension = Objects.requireNonNull(dimension);
-    }
+  /**
+   * Creates an instance of this average degree evolution operator.
+   *
+   * @param degreeType the degree type to use (IN, OUT, BOTH).
+   * @param dimension  the time dimension to use (VALID_TIME, TRANSACTION_TIME).
+   *
+   * @throws RuntimeException in case of an error.
+   */
+  public AvgDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException {
+    this.degreeType = Objects.requireNonNull(degreeType);
+    this.dimension = Objects.requireNonNull(dimension);
+  }
 
-    @Override
-    public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
-        DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
-                // 1) Extract vertex id(s) and corresponding time intervals
-                .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
-                // 2) Group them by the vertex id
-                .groupBy(0)
-                // 3) For each vertex id, build a degree tree data structure
-                .reduceGroup(new BuildTemporalDegreeTree())
-                // 4) Transform each tree to aggregated evolution
-                .map(new TransformDeltaToAbsoluteDegreeTree());
+  @Override
+  public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
+    DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
+        // 1) Extract vertex id(s) and corresponding time intervals
+        .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
+        // 2) Group them by the vertex id
+        .groupBy(0)
+        // 3) For each vertex id, build a degree tree data structure
+        .reduceGroup(new BuildTemporalDegreeTree())
+        // 4) Transform each tree to aggregated evolution
+        .map(new TransformDeltaToAbsoluteDegreeTree());
 
-        DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
-                // 5) extract all timestamps where degree of any vertex changes
-                .reduceGroup(new ExtractAllTimePointsReduce())
-                .distinct();
+    DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
+        // 5) extract all timestamps where degree of any vertex changes
+        .reduceGroup(new ExtractAllTimePointsReduce())
+        .distinct();
 
-        return absoluteDegreeTrees
-                // 6) Merge trees together and calculate aggregation
-                .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.AVG, timePoints));
+    return absoluteDegreeTrees
+        // 6) Merge trees together and calculate aggregation
+        .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.AVG, timePoints));
 
-    }
+  }
 }

gradoop-temporal/src/main/java/org/gradoop/temporal/model/impl/operators/metric/MaxDegreeEvolution.java

@@ -23,7 +23,12 @@
 import org.gradoop.flink.model.impl.operators.sampling.functions.VertexDegree;
 import org.gradoop.temporal.model.api.TimeDimension;
 import org.gradoop.temporal.model.impl.TemporalGraph;
-import org.gradoop.temporal.model.impl.operators.metric.functions.*;
+import org.gradoop.temporal.model.impl.operators.metric.functions.GroupDegreeTreesToAggregateDegrees;
+import org.gradoop.temporal.model.impl.operators.metric.functions.TransformDeltaToAbsoluteDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.FlatMapVertexIdEdgeInterval;
+import org.gradoop.temporal.model.impl.operators.metric.functions.BuildTemporalDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.ExtractAllTimePointsReduce;
+import org.gradoop.temporal.model.impl.operators.metric.functions.AggregateType;
 
 import java.util.Objects;
 import java.util.TreeMap;
@@ -33,48 +38,50 @@
  * whole lifetime of the graph.
  */
 public class MaxDegreeEvolution
-        implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
-    /**
-     * The time dimension that will be considered.
-     */
-    private final TimeDimension dimension;
+    implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
+  /**
+   * The time dimension that will be considered.
+   */
+  private final TimeDimension dimension;
 
-    /**
-     * The degree type (IN, OUT, BOTH);
-     */
-    private final VertexDegree degreeType;
+  /**
+   * The degree type (IN, OUT, BOTH);
+   */
+  private final VertexDegree degreeType;
 
-    /**
-     * Creates an instance of this maximum degree evolution operator.
-     *
-     * @param degreeType the degree type to use (IN, OUT, BOTH).
-     * @param dimension the time dimension to use (VALID_TIME, TRANSACTION_TIME).
-     */
-    public MaxDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException {
-        this.degreeType = Objects.requireNonNull(degreeType);
-        this.dimension = Objects.requireNonNull(dimension);
-    }
+  /**
+   * Creates an instance of this maximum degree evolution operator.
+   *
+   * @param degreeType the degree type to use (IN, OUT, BOTH).
+   * @param dimension  the time dimension to use (VALID_TIME, TRANSACTION_TIME).
+   *
+   * @throws RuntimeException in case of an error.
+   */
+  public MaxDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException {
+    this.degreeType = Objects.requireNonNull(degreeType);
+    this.dimension = Objects.requireNonNull(dimension);
+  }
 
-    @Override
-    public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
-        DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
-                // 1) Extract vertex id(s) and corresponding time intervals
-                .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
-                // 2) Group them by the vertex id
-                .groupBy(0)
-                // 3) For each vertex id, build a degree tree data structure
-                .reduceGroup(new BuildTemporalDegreeTree())
-                // 4) Transform each tree to aggregated evolution
-                .map(new TransformDeltaToAbsoluteDegreeTree());
+  @Override
+  public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
+    DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
+        // 1) Extract vertex id(s) and corresponding time intervals
+        .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
+        // 2) Group them by the vertex id
+        .groupBy(0)
+        // 3) For each vertex id, build a degree tree data structure
+        .reduceGroup(new BuildTemporalDegreeTree())
+        // 4) Transform each tree to aggregated evolution
+        .map(new TransformDeltaToAbsoluteDegreeTree());
 
-        DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
-                // 5) extract all timestamps where degree of any vertex changes
-                .reduceGroup(new ExtractAllTimePointsReduce())
-                .distinct();
+    DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
+        // 5) extract all timestamps where degree of any vertex changes
+        .reduceGroup(new ExtractAllTimePointsReduce())
+        .distinct();
 
-        return absoluteDegreeTrees
-                // 6) Merge trees together and calculate aggregation
-                .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.AVG, timePoints));
+    return absoluteDegreeTrees
+        // 6) Merge trees together and calculate aggregation
+        .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.MAX, timePoints));
 
-    }
+  }
 }

gradoop-temporal/src/main/java/org/gradoop/temporal/model/impl/operators/metric/MinDegreeEvolution.java

@@ -23,7 +23,12 @@
 import org.gradoop.flink.model.impl.operators.sampling.functions.VertexDegree;
 import org.gradoop.temporal.model.api.TimeDimension;
 import org.gradoop.temporal.model.impl.TemporalGraph;
-import org.gradoop.temporal.model.impl.operators.metric.functions.*;
+import org.gradoop.temporal.model.impl.operators.metric.functions.GroupDegreeTreesToAggregateDegrees;
+import org.gradoop.temporal.model.impl.operators.metric.functions.TransformDeltaToAbsoluteDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.FlatMapVertexIdEdgeInterval;
+import org.gradoop.temporal.model.impl.operators.metric.functions.BuildTemporalDegreeTree;
+import org.gradoop.temporal.model.impl.operators.metric.functions.ExtractAllTimePointsReduce;
+import org.gradoop.temporal.model.impl.operators.metric.functions.AggregateType;
 
 import java.util.Objects;
 import java.util.TreeMap;
@@ -33,48 +38,49 @@
  * whole lifetime of the graph.
  */
 public class MinDegreeEvolution
-        implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
-    /**
-     * The time dimension that will be considered.
-     */
-    private final TimeDimension dimension;
+    implements UnaryBaseGraphToValueOperator<TemporalGraph, DataSet<Tuple2<Long, Integer>>> {
+  /**
+   * The time dimension that will be considered.
+   */
+  private final TimeDimension dimension;
 
-    /**
-     * The degree type (IN, OUT, BOTH);
-     */
-    private final VertexDegree degreeType;
+  /**
+   * The degree type (IN, OUT, BOTH);
+   */
+  private final VertexDegree degreeType;
 
-    /**
-     * Creates an instance of this minimum degree evolution operator.
-     *
-     * @param degreeType the degree type to use (IN, OUT, BOTH).
-     * @param dimension the time dimension to use (VALID_TIME, TRANSACTION_TIME).
-     */
-    public MinDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException {
-        this.degreeType = Objects.requireNonNull(degreeType);
-        this.dimension = Objects.requireNonNull(dimension);
-    }
+  /**
+   * Creates an instance of this minimum degree evolution operator.
+   *
+   * @param degreeType the degree type to use (IN, OUT, BOTH).
+   * @param dimension  the time dimension to use (VALID_TIME, TRANSACTION_TIME).
+   *
+   * @throws RuntimeException in case of an error.
+   */
+  public MinDegreeEvolution(VertexDegree degreeType, TimeDimension dimension) throws RuntimeException {
+    this.degreeType = Objects.requireNonNull(degreeType);
+    this.dimension = Objects.requireNonNull(dimension);
+  }
 
-    @Override
-    public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
-        DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
-                // 1) Extract vertex id(s) and corresponding time intervals
-                .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
-                // 2) Group them by the vertex id
-                .groupBy(0)
-                // 3) For each vertex id, build a degree tree data structure
-                .reduceGroup(new BuildTemporalDegreeTree())
-                // 4) Transform each tree to aggregated evolution
-                .map(new TransformDeltaToAbsoluteDegreeTree());
+  @Override
+  public DataSet<Tuple2<Long, Integer>> execute(TemporalGraph graph) {
+    DataSet<Tuple2<GradoopId, TreeMap<Long, Integer>>> absoluteDegreeTrees = graph.getEdges()
+        // 1) Extract vertex id(s) and corresponding time intervals
+        .flatMap(new FlatMapVertexIdEdgeInterval(dimension, degreeType))
+        // 2) Group them by the vertex id
+        .groupBy(0)
+        // 3) For each vertex id, build a degree tree data structure
+        .reduceGroup(new BuildTemporalDegreeTree())
+        // 4) Transform each tree to aggregated evolution
+        .map(new TransformDeltaToAbsoluteDegreeTree());
 
-        DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
-                // 5) extract all timestamps where degree of any vertex changes
-                .reduceGroup(new ExtractAllTimePointsReduce())
-                .distinct();
+    DataSet<Tuple1<Long>> timePoints = absoluteDegreeTrees
+        // 5) extract all timestamps where degree of any vertex changes
+        .reduceGroup(new ExtractAllTimePointsReduce())
+        .distinct();
 
-        return absoluteDegreeTrees
-                // 6) Merge trees together and calculate aggregation
-                .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.AVG, timePoints));
-
-    }
+    return absoluteDegreeTrees
+        // 6) Merge trees together and calculate aggregation
+        .reduceGroup(new GroupDegreeTreesToAggregateDegrees(AggregateType.MIN, timePoints));
+  }
 }

gradoop-temporal/src/main/java/org/gradoop/temporal/model/impl/operators/metric/functions/AggregateType.java

@@ -1,19 +1,34 @@
+/*
+ * Copyright © 2014 - 2021 Leipzig University (Database Research Group)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.gradoop.temporal.model.impl.operators.metric.functions;
 
 /**
  * Enum for defining an aggregate type.
  */
 public enum AggregateType {
-    /**
-     * Minimum aggregation.
-     */
-    MIN,
-    /**
-     * Maximum aggregation.
-     */
-    MAX,
-    /**
-     * Average aggregation.
-     */
-    AVG
+  /**
+   * Minimum aggregation.
+   */
+  MIN,
+  /**
+   * Maximum aggregation.
+   */
+  MAX,
+  /**
+   * Average aggregation.
+   */
+  AVG
 }

gradoop-temporal/src/main/java/org/gradoop/temporal/model/impl/operators/metric/functions/ExtractAllTimePointsReduce.java

@@ -30,20 +30,24 @@
  */
 public class ExtractAllTimePointsReduce implements GroupReduceFunction<Tuple2<GradoopId, TreeMap<Long, Integer>>, Tuple1<Long>> {
 
-    public ExtractAllTimePointsReduce() {
+  /**
+   * Creates an instance of the group reduce function.
+   */
+  public ExtractAllTimePointsReduce() {
+  }
+
+  @Override
+  public void reduce(Iterable<Tuple2<GradoopId, TreeMap<Long, Integer>>> iterable,
+                     Collector<Tuple1<Long>> collector) throws Exception {
+    SortedSet<Long> timePoints = new TreeSet<>();
+
+    for (Tuple2<GradoopId, TreeMap<Long, Integer>> tuple : iterable) {
+      timePoints.addAll(tuple.f1.keySet());
     }
 
-    @Override
-    public void reduce(Iterable<Tuple2<GradoopId, TreeMap<Long, Integer>>> iterable, Collector<Tuple1<Long>> collector) throws Exception {
-        SortedSet<Long> timePoints = new TreeSet<>();
-
-        for (Tuple2<GradoopId, TreeMap<Long, Integer>> tuple : iterable) {
-            timePoints.addAll(tuple.f1.keySet());
-        }
-
-        for (Long timePoint: timePoints) {
-            collector.collect(new Tuple1<>(timePoint));
-        }
-
+    for (Long timePoint : timePoints) {
+      collector.collect(new Tuple1<>(timePoint));
     }
+
+  }
 }