GetDataRunnable: Move away from streams

Signed-off-by: Taylor Smock <tsmock@fb.com>

src/main/java/org/openstreetmap/josm/plugins/mapwithai/backend/GetDataRunnable.java

@@ -317,22 +317,34 @@ public class GetDataRunnable extends RecursiveTask<DataSet> {
     public static void removeAlreadyAddedData(DataSet dataSet) {
         final List<DataSet> osmData = MainApplication.getLayerManager().getLayersOfType(OsmDataLayer.class).stream()
                 .map(OsmDataLayer::getDataSet).filter(ds -> !ds.equals(dataSet)).collect(Collectors.toList());
-        dataSet.getWays().stream().filter(way -> !way.isDeleted() && way.getOsmId() <= 0)
+        for (Way way : dataSet.getWays()) {
-                .filter(way -> osmData.stream().anyMatch(ds -> checkIfPrimitiveDuplicatesPrimitiveInDataSet(way, ds)))
+            if (!way.isDeleted() && way.getOsmId() <= 0) {
-                .forEach(way -> {
+                for (DataSet ds : osmData) {
-                    final List<Node> nodes = way.getNodes();
+                    if (checkIfPrimitiveDuplicatesPrimitiveInDataSet(way, ds)) {
-                    Optional.ofNullable(DeleteCommand.delete(Collections.singleton(way), true, true))
+                        final List<Node> nodes = way.getNodes();
-                            .ifPresent(Command::executeCommand);
+                        Optional.ofNullable(DeleteCommand.delete(Collections.singleton(way), true, true))
-                    nodes.stream().filter(
+                                .ifPresent(Command::executeCommand);
-                            node -> !node.isDeleted() && node.getReferrers().stream().allMatch(OsmPrimitive::isDeleted))
+                        for (Node node : nodes) {
-                            .forEach(node -> node.setDeleted(true));
+                            if (!node.isDeleted()
-                });
+                                    && node.referrers(OsmPrimitive.class).allMatch(OsmPrimitive::isDeleted)) {
+                                node.setDeleted(true);
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }
     }
 
     private static boolean checkIfPrimitiveDuplicatesPrimitiveInDataSet(OsmPrimitive primitive, DataSet ds) {
         final List<OsmPrimitive> possibleDuplicates = searchDataSet(ds, primitive);
-        return possibleDuplicates.stream().filter(prim -> !prim.isDeleted())
+        for (OsmPrimitive dupe : possibleDuplicates) {
-                .anyMatch(prim -> checkIfProbableDuplicate(prim, primitive));
+            if (checkIfProbableDuplicate(dupe, primitive)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     private static boolean checkIfProbableDuplicate(OsmPrimitive one, OsmPrimitive two) {
@@ -362,19 +374,18 @@ public class GetDataRunnable extends RecursiveTask<DataSet> {
     }
 
     private static <T extends AbstractPrimitive> List<OsmPrimitive> searchDataSet(DataSet ds, T primitive) {
-        List<OsmPrimitive> returnList = Collections.emptyList();
         if (primitive instanceof OsmPrimitive) {
             final BBox tBBox = new BBox();
             tBBox.addPrimitive((OsmPrimitive) primitive, DEGREE_BUFFER);
             if (primitive instanceof Node) {
-                returnList = new ArrayList<>(ds.searchNodes(tBBox));
+                return new ArrayList<>(ds.searchNodes(tBBox));
             } else if (primitive instanceof Way) {
-                returnList = new ArrayList<>(ds.searchWays(tBBox));
+                return new ArrayList<>(ds.searchWays(tBBox));
             } else if (primitive instanceof Relation) {
-                returnList = new ArrayList<>(ds.searchRelations(tBBox));
+                return new ArrayList<>(ds.searchRelations(tBBox));
             }
         }
-        return returnList;
+        return Collections.emptyList();
     }
 
     /**