diff --git a/Core/src/main/java/com/plotsquared/core/PlotSquared.java b/Core/src/main/java/com/plotsquared/core/PlotSquared.java index af94ed1dde..c053c822a2 100644 --- a/Core/src/main/java/com/plotsquared/core/PlotSquared.java +++ b/Core/src/main/java/com/plotsquared/core/PlotSquared.java @@ -713,8 +713,6 @@ private void sortPlotsByHash(final @NonNull Plot @NonNull [] input) { case CREATION_DATE_TIMESTAMP -> toReturn.addAll(sortPlotsByTimestamp(map.get(area))); case DISTANCE_FROM_ORIGIN -> toReturn.addAll(sortPlotsByHash(map.get(area))); case LAST_MODIFIED -> toReturn.addAll(sortPlotsByModified(map.get(area))); - default -> { - } } } return toReturn; diff --git a/Core/src/main/java/com/plotsquared/core/command/Visit.java b/Core/src/main/java/com/plotsquared/core/command/Visit.java index 1eeea894d1..7d04784c33 100644 --- a/Core/src/main/java/com/plotsquared/core/command/Visit.java +++ b/Core/src/main/java/com/plotsquared/core/command/Visit.java @@ -67,13 +67,10 @@ public Visit(final @NonNull PlotAreaManager plotAreaManager) { private void visit( final @NonNull PlotPlayer player, final @NonNull PlotQuery query, final PlotArea sortByArea, - final RunnableVal3 confirm, final RunnableVal2 whenDone, int page + final RunnableVal3 confirm, final RunnableVal2 whenDone, + int page, final boolean isQueryingBasePlot ) { - // We get the query once, - // then we get it another time further on - final List unsorted = query.asList(); - - if (unsorted.size() > 1) { + if (!isQueryingBasePlot && query.hasMinimumMatches(2)) { query.whereBasePlot(); } @@ -237,7 +234,8 @@ public CompletableFuture execute( finalSortByArea, confirm, whenDone, - finalPage1 + finalPage1, + true ); } }); @@ -261,12 +259,9 @@ public CompletableFuture execute( if (throwable instanceof TimeoutException) { // The request timed out player.sendMessage(TranslatableCaption.of("players.fetching_players_timeout")); - } else if (uuid != null && (Settings.Teleport.VISIT_MERGED_OWNERS - ? !PlotQuery.newQuery().ownersInclude(uuid).anyMatch() - : !PlotQuery.newQuery().ownedBy(uuid).anyMatch())) { - // It was a valid UUID but the player has no plots - player.sendMessage(TranslatableCaption.of("errors.player_no_plots")); - } else if (uuid == null) { + return; + } + if (uuid == null){ // player not found, so we assume it's an alias if no page was provided if (finalPage == Integer.MIN_VALUE) { this.visit( @@ -275,7 +270,8 @@ public CompletableFuture execute( player.getApplicablePlotArea(), confirm, whenDone, - 1 + 1, + false ); } else { player.sendMessage( @@ -283,24 +279,23 @@ public CompletableFuture execute( TagResolver.resolver("value", Tag.inserting(Component.text(finalArgs[0]))) ); } - } else { - this.visit( - player, - Settings.Teleport.VISIT_MERGED_OWNERS - ? PlotQuery.newQuery().ownersInclude(uuid).whereBasePlot() - : PlotQuery.newQuery().ownedBy(uuid).whereBasePlot(), - null, - confirm, - whenDone, - finalPage - ); + return; + } + final PlotQuery query = Settings.Teleport.VISIT_MERGED_OWNERS + ? PlotQuery.newQuery().ownersInclude(uuid) + : PlotQuery.newQuery().ownedBy(uuid); + if (!query.anyMatch()) { + // It was a valid UUID but the player has no plots + player.sendMessage(TranslatableCaption.of("errors.player_no_plots")); + return; } + this.visit(player, query.whereBasePlot(), null, confirm, whenDone, finalPage, true); }); } else { // Try to parse a plot final Plot plot = Plot.getPlotFromString(player, finalArgs[0], true); if (plot != null) { - this.visit(player, PlotQuery.newQuery().withPlot(plot), null, confirm, whenDone, 1); + this.visit(player, PlotQuery.newQuery().withPlot(plot), null, confirm, whenDone, 1, false); } } break; diff --git a/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByCreationDateComparator.java b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByCreationDateComparator.java new file mode 100644 index 0000000000..a6247703ec --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByCreationDateComparator.java @@ -0,0 +1,50 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.util.comparator; + +import com.plotsquared.core.plot.Plot; + +import java.util.Comparator; + +/** + * Sort plots by {@link Plot#temp} (being the auto increment id in database) in natural order for {@code temp > 0}. + * For {@code temp < 1} sort by {@link Plot#hashCode()} + */ +public class PlotByCreationDateComparator implements Comparator { + + public static final Comparator INSTANCE = new PlotByCreationDateComparator(); + + private PlotByCreationDateComparator() { + } + + @Override + @SuppressWarnings("deprecation") // Plot#temp + public int compare(final Plot first, final Plot second) { + if (first.temp > 0 && second.temp > 0) { + return Integer.compare(first.temp, second.temp); + } + // second is implicitly `< 1` (due to previous condition) + if (first.temp > 0) { + return 1; + } + // sort dangling plots (temp < 1) by their hashcode + return Integer.compare(first.hashCode(), second.hashCode()); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByDoneComparator.java b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByDoneComparator.java new file mode 100644 index 0000000000..af836c41e0 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByDoneComparator.java @@ -0,0 +1,52 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.util.comparator; + +import com.plotsquared.core.plot.Plot; +import com.plotsquared.core.plot.flag.implementations.DoneFlag; +import com.plotsquared.core.util.MathMan; + +import java.util.Comparator; + +/** + * Sort plots by their {@link DoneFlag} in reverse numeric natural order. (more recent "finished plots" first) + *
+ * Non-finished plots last, unsorted. + */ +public class PlotByDoneComparator implements Comparator { + + public static final PlotByDoneComparator INSTANCE = new PlotByDoneComparator(); + + private PlotByDoneComparator() { + } + + @Override + public int compare(final Plot first, final Plot second) { + String firstDone = first.getFlag(DoneFlag.class); + String lastDone = second.getFlag(DoneFlag.class); + if (MathMan.isInteger(firstDone)) { + if (MathMan.isInteger(lastDone)) { + return Integer.parseInt(lastDone) - Integer.parseInt(firstDone); + } + return -1; // only "first" is finished, so sort "second" after "first" + } + return 0; // neither is finished + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByRatingComparator.java b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByRatingComparator.java new file mode 100644 index 0000000000..2043d4b146 --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotByRatingComparator.java @@ -0,0 +1,61 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.util.comparator; + +import com.plotsquared.core.plot.Plot; +import com.plotsquared.core.plot.Rating; + +import java.util.Comparator; +import java.util.Map; +import java.util.UUID; + +public class PlotByRatingComparator implements Comparator { + + public static final PlotByRatingComparator INSTANCE = new PlotByRatingComparator(); + + PlotByRatingComparator() { + } + + @Override + public int compare(final Plot p1, final Plot p2) { + double v1 = 0; + int p1s = p1.getSettings().getRatings().size(); + int p2s = p2.getRatings().size(); + if (!p1.getSettings().getRatings().isEmpty()) { + v1 = p1.getRatings().values().stream().mapToDouble(Rating::getAverageRating) + .map(av -> av * av).sum(); + v1 /= p1s; + v1 += p1s; + } + double v2 = 0; + if (!p2.getSettings().getRatings().isEmpty()) { + for (Map.Entry entry : p2.getRatings().entrySet()) { + double av = entry.getValue().getAverageRating(); + v2 += av * av; + } + v2 /= p2s; + v2 += p2s; + } + if (v2 == v1 && v2 != 0) { + return p2s - p1s; + } + return (int) Math.signum(v2 - v1); + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/util/comparator/PlotInPrioritizedAreaComparator.java b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotInPrioritizedAreaComparator.java new file mode 100644 index 0000000000..cbd0744f6a --- /dev/null +++ b/Core/src/main/java/com/plotsquared/core/util/comparator/PlotInPrioritizedAreaComparator.java @@ -0,0 +1,49 @@ +/* + * PlotSquared, a land and world management plugin for Minecraft. + * Copyright (C) IntellectualSites + * Copyright (C) IntellectualSites team and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.plotsquared.core.util.comparator; + +import com.plotsquared.core.plot.Plot; +import com.plotsquared.core.plot.PlotArea; + +import javax.annotation.Nullable; +import java.util.Comparator; + +public class PlotInPrioritizedAreaComparator implements Comparator { + + private final PlotArea priorityArea; + + public PlotInPrioritizedAreaComparator(@Nullable final PlotArea area) { + this.priorityArea = area; + } + + @Override + public int compare(final Plot first, final Plot second) { + if (this.priorityArea == null) { + return 0; // no defined priority? don't sort + } + if (this.priorityArea.equals(first.getArea())) { + return -1; + } + if (this.priorityArea.equals(second.getArea())) { + return 1; + } + return 0; // same area, don't sort + } + +} diff --git a/Core/src/main/java/com/plotsquared/core/util/query/AreaLimitedPlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/AreaLimitedPlotProvider.java index 185bd58cf9..5f4e99107e 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/AreaLimitedPlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/AreaLimitedPlotProvider.java @@ -24,6 +24,7 @@ import java.util.Collection; import java.util.LinkedList; import java.util.List; +import java.util.stream.Stream; class AreaLimitedPlotProvider implements PlotProvider { @@ -42,4 +43,9 @@ public Collection getPlots() { return plots; } + @Override + public Stream streamPlots() { + return streamPlotsInPlotAreas(this.areas.toArray(PlotArea[]::new)); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/ExpiredPlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/ExpiredPlotProvider.java index 1fac18f2c9..f43e7b58bf 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/ExpiredPlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/ExpiredPlotProvider.java @@ -22,6 +22,7 @@ import com.plotsquared.core.plot.Plot; import java.util.Collection; +import java.util.stream.Stream; class ExpiredPlotProvider implements PlotProvider { @@ -30,4 +31,9 @@ public Collection getPlots() { return PlotSquared.platform().expireManager().getPendingExpired(); } + @Override + public Stream streamPlots() { + return getPlots().stream(); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/FixedPlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/FixedPlotProvider.java index a8f43a024d..dce320997a 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/FixedPlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/FixedPlotProvider.java @@ -23,6 +23,7 @@ import java.util.Collection; import java.util.Collections; +import java.util.stream.Stream; class FixedPlotProvider implements PlotProvider { @@ -37,4 +38,9 @@ public Collection getPlots() { return Collections.singleton(plot); } + @Override + public Stream streamPlots() { + return Stream.of(plot); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/GlobalPlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/GlobalPlotProvider.java index e02994e637..4553498b56 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/GlobalPlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/GlobalPlotProvider.java @@ -26,6 +26,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.stream.Stream; class GlobalPlotProvider implements PlotProvider { @@ -44,4 +45,9 @@ public Collection getPlots() { return plots; } + @Override + public Stream streamPlots() { + return streamPlotsInPlotAreas(this.plotAreaManager.getAllPlotAreas()); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/NullProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/NullProvider.java index 17f0c752dc..5120442f55 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/NullProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/NullProvider.java @@ -22,6 +22,7 @@ import java.util.Collection; import java.util.Collections; +import java.util.stream.Stream; class NullProvider implements PlotProvider { @@ -30,4 +31,9 @@ public Collection getPlots() { return Collections.emptyList(); } + @Override + public Stream streamPlots() { + return Stream.empty(); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/OwnersIncludeFilter.java b/Core/src/main/java/com/plotsquared/core/util/query/OwnersIncludeFilter.java index 8a9969b3e1..fc54c0d41a 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/OwnersIncludeFilter.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/OwnersIncludeFilter.java @@ -23,17 +23,11 @@ import java.util.UUID; -class OwnersIncludeFilter implements PlotFilter { - - private final UUID owner; - - OwnersIncludeFilter(final @NonNull UUID owner) { - this.owner = owner; - } +record OwnersIncludeFilter(UUID owner) implements PlotFilter { @Override public boolean accepts(final @NonNull Plot plot) { - return plot.isBasePlot() && plot.getOwners().size() > 0 && plot.getOwners().contains(owner); + return plot.isBasePlot() && plot.isOwner(owner); } } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/PlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/PlotProvider.java index 05c6d54ba5..06548c6202 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/PlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/PlotProvider.java @@ -19,12 +19,44 @@ package com.plotsquared.core.util.query; import com.plotsquared.core.plot.Plot; +import com.plotsquared.core.plot.PlotArea; import java.util.Collection; +import java.util.Iterator; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; -@FunctionalInterface interface PlotProvider { Collection getPlots(); + Stream streamPlots(); + + default Stream streamPlotsInPlotAreas(PlotArea[] areas) { + if (areas == null || areas.length == 0) { + return Stream.of(); + } + return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Iterator<>() { + private int areaIndex = -1; + private Iterator currentAreaPlots; + @Override + public boolean hasNext() { + if (currentAreaPlots == null || !currentAreaPlots.hasNext()) { + if (areaIndex >= areas.length - 1) { + return false; + } + currentAreaPlots = areas[++areaIndex].getPlots().iterator(); + } + return true; + } + + @Override + public Plot next() { + return currentAreaPlots.next(); + } + }, Spliterator.IMMUTABLE), false); + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/PlotQuery.java b/Core/src/main/java/com/plotsquared/core/util/query/PlotQuery.java index 7a3533d355..43af783702 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/PlotQuery.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/PlotQuery.java @@ -23,10 +23,11 @@ import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.PlotArea; -import com.plotsquared.core.plot.Rating; -import com.plotsquared.core.plot.flag.implementations.DoneFlag; import com.plotsquared.core.plot.world.PlotAreaManager; -import com.plotsquared.core.util.MathMan; +import com.plotsquared.core.util.comparator.PlotByDoneComparator; +import com.plotsquared.core.util.comparator.PlotByRatingComparator; +import com.plotsquared.core.util.comparator.PlotByCreationDateComparator; +import com.plotsquared.core.util.comparator.PlotInPrioritizedAreaComparator; import org.checkerframework.checker.nullness.qual.NonNull; import java.util.ArrayList; @@ -37,7 +38,6 @@ import java.util.Iterator; import java.util.LinkedList; import java.util.List; -import java.util.Map; import java.util.Set; import java.util.UUID; import java.util.function.Predicate; @@ -229,6 +229,7 @@ public static PlotQuery newQuery() { public @NonNull PlotQuery hasOwner() { return this.addFilter(new HasOwnerFilter()); } + /** * Query for plots with a specific alias * @@ -307,7 +308,15 @@ public static PlotQuery newQuery() { * @return Matching plots */ public @NonNull Stream asStream() { - return this.asList().stream(); + Stream stream = this.plotProvider.streamPlots().filter(testPlotAgainstFilters()); + if (this.sortingStrategy == SortingStrategy.NO_SORTING) { + return stream; + } + stream = stream.sorted(getConfiguredComparator()); + if (this.priorityArea != null) { + stream = stream.sorted(new PlotInPrioritizedAreaComparator(this.priorityArea)); + } + return stream; } /** @@ -334,49 +343,10 @@ public static PlotQuery newQuery() { } if (this.sortingStrategy == SortingStrategy.NO_SORTING) { return result; - } else if (this.sortingStrategy == SortingStrategy.SORT_BY_TEMP) { - return PlotSquared.get().sortPlotsByTemp(result); - } else if (this.sortingStrategy == SortingStrategy.SORT_BY_DONE) { - result.sort((a, b) -> { - String va = a.getFlag(DoneFlag.class); - String vb = b.getFlag(DoneFlag.class); - if (MathMan.isInteger(va)) { - if (MathMan.isInteger(vb)) { - return Integer.parseInt(vb) - Integer.parseInt(va); - } - return -1; - } - return 1; - }); - } else if (this.sortingStrategy == SortingStrategy.SORT_BY_RATING) { - result.sort((p1, p2) -> { - double v1 = 0; - int p1s = p1.getSettings().getRatings().size(); - int p2s = p2.getRatings().size(); - if (!p1.getSettings().getRatings().isEmpty()) { - v1 = p1.getRatings().values().stream().mapToDouble(Rating::getAverageRating) - .map(av -> av * av).sum(); - v1 /= p1s; - v1 += p1s; - } - double v2 = 0; - if (!p2.getSettings().getRatings().isEmpty()) { - for (Map.Entry entry : p2.getRatings().entrySet()) { - double av = entry.getValue().getAverageRating(); - v2 += av * av; - } - v2 /= p2s; - v2 += p2s; - } - if (v2 == v1 && v2 != 0) { - return p2s - p1s; - } - return (int) Math.signum(v2 - v1); - }); - } else if (this.sortingStrategy == SortingStrategy.SORT_BY_CREATION) { - return PlotSquared.get().sortPlots(result, PlotSquared.SortType.CREATION_DATE, this.priorityArea); - } else if (this.sortingStrategy == SortingStrategy.COMPARATOR) { - result.sort(this.plotComparator); + } + result.sort(getConfiguredComparator()); + if (this.priorityArea != null) { + result.sort(new PlotInPrioritizedAreaComparator(this.priorityArea)); } return result; } @@ -427,28 +397,22 @@ public int count() { * @return {@code true} if any provided plot matches the filters. */ public boolean anyMatch() { - if (this.filters.isEmpty()) { - return !this.plotProvider.getPlots().isEmpty(); - } else { - final Collection plots = this.plotProvider.getPlots(); - outer: - for (final Plot plot : plots) { - // a plot must pass all filters to match the criteria - for (final PlotFilter filter : this.filters) { - if (!filter.accepts(plot)) { - continue outer; - } - } - return true; // a plot passed all filters, so we have a match - } - return false; - } + return hasMinimumMatches(1); } - @NonNull - private PlotQuery addFilter(final @NonNull PlotFilter filter) { - this.filters.add(filter); - return this; + /** + * Get whether this query matches at least {@code minimum} plots. + *
+ * Should be prioritized over {@link #count()}, if possible. + * This method only queries as many plots and areas as required without applying sorting. (short-circuiting on the stream) + * + * @param minimum the minimum amount of matches plots expected (inclusive) + * @return {@code true} if this query's result contains at least {@code minimum} plots (after optional filters). + * + * @since TODO + */ + public boolean hasMinimumMatches(int minimum) { + return this.plotProvider.streamPlots().filter(testPlotAgainstFilters()).limit(minimum).count() == minimum; } @NonNull @@ -457,4 +421,34 @@ public Iterator iterator() { return this.asCollection().iterator(); } + @NonNull + private PlotQuery addFilter(final @NonNull PlotFilter filter) { + this.filters.add(filter); + return this; + } + + private Comparator getConfiguredComparator() { + return switch (sortingStrategy) { + case NO_SORTING -> (p1, p2) -> 0; + case SORT_BY_TEMP, SORT_BY_CREATION -> PlotByCreationDateComparator.INSTANCE; + case SORT_BY_DONE -> PlotByDoneComparator.INSTANCE; + case SORT_BY_RATING -> PlotByRatingComparator.INSTANCE; + case COMPARATOR -> plotComparator; + }; + } + + private Predicate testPlotAgainstFilters() { + if (this.filters.isEmpty()) { + return plot -> true; + } + return plot -> { + for (final PlotFilter filter : filters) { + if (!filter.accepts(plot)) { + return false; + } + } + return true; + }; + } + } diff --git a/Core/src/main/java/com/plotsquared/core/util/query/SearchPlotProvider.java b/Core/src/main/java/com/plotsquared/core/util/query/SearchPlotProvider.java index df8f485b64..76d2195f64 100644 --- a/Core/src/main/java/com/plotsquared/core/util/query/SearchPlotProvider.java +++ b/Core/src/main/java/com/plotsquared/core/util/query/SearchPlotProvider.java @@ -31,6 +31,7 @@ import java.util.UUID; import java.util.stream.Collectors; import java.util.stream.IntStream; +import java.util.stream.Stream; class SearchPlotProvider implements PlotProvider { @@ -115,4 +116,9 @@ public Collection getPlots() { return getPlotsBySearch(this.searchTerm); } + @Override + public Stream streamPlots() { + return getPlots().stream(); // TODO: look into potentially optimizations here? + } + }