Some small cleanup changes

common/src/main/java/me/lucko/luckperms/common/bulkupdate/comparison/Constraint.java

@@ -37,7 +37,6 @@ public class Constraint {
     private final String expressionValue;
     private final Comparison.CompiledExpression compiledExpression;
 
-
     private Constraint(Comparison comparison, String expression) {
         this.comparison = comparison;
         this.expressionValue = expression;

common/src/main/java/me/lucko/luckperms/common/cache/MRUCache.java

@@ -0,0 +1,58 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.common.cache;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Implementation of a most-recently-used cache with a mod counter, to prevent race conditions
+ * occurring when the cache is cleared whilst a calculation is taking place.
+ *
+ * @param <T> the cached type
+ */
+public abstract class MRUCache<T> {
+    private volatile T recent;
+    private final AtomicInteger modCount = new AtomicInteger();
+
+    protected int modCount() {
+        return this.modCount.get();
+    }
+
+    protected T getRecent() {
+        return this.recent;
+    }
+
+    protected void offerRecent(int validAt, T offer) {
+        if (validAt == this.modCount.get()) {
+            this.recent = offer;
+        }
+    }
+
+    protected void clearRecent() {
+        this.recent = null;
+        this.modCount.incrementAndGet();
+    }
+}

common/src/main/java/me/lucko/luckperms/common/cacheddata/AbstractCachedDataManager.java

@@ -28,6 +28,7 @@ package me.lucko.luckperms.common.cacheddata;
 import com.github.benmanes.caffeine.cache.AsyncLoadingCache;
 import com.github.benmanes.caffeine.cache.CacheLoader;
 
+import me.lucko.luckperms.common.cache.MRUCache;
 import me.lucko.luckperms.common.cacheddata.type.MetaAccumulator;
 import me.lucko.luckperms.common.cacheddata.type.MetaCache;
 import me.lucko.luckperms.common.cacheddata.type.PermissionCache;
@@ -52,7 +53,6 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * Abstract implementation of {@link CachedDataManager}.
@@ -179,36 +179,6 @@ public abstract class AbstractCachedDataManager implements CachedDataManager {
         this.metaDataManager.cache.synchronous().cleanUp();
     }
 
-    /**
-     * Implementation of a most-recently-used cache with a mod counter, to prevent race conditions
-     * occurring when the cache is cleared whilst a calculation is taking place.
-     *
-     * @param <T> the cached type
-     */
-    private abstract static class MRUCache<T> {
-        private volatile T recent;
-        private final AtomicInteger modCount = new AtomicInteger();
-
-        protected int modCount() {
-            return this.modCount.get();
-        }
-
-        protected T getRecent() {
-            return this.recent;
-        }
-
-        protected void offerRecent(int validAt, T offer) {
-            if (validAt == this.modCount.get()) {
-                this.recent = offer;
-            }
-        }
-
-        protected void clearRecent() {
-            this.recent = null;
-            this.modCount.incrementAndGet();
-        }
-    }
-
     private final class Permission extends MRUCache<RecentPermissionData> implements Container<CachedPermissionData> {
         private final AsyncLoadingCache<QueryOptions, PermissionCache> cache = CaffeineFactory.newBuilder()
                 .expireAfterAccess(2, TimeUnit.MINUTES)

sponge/src/main/java/me/lucko/luckperms/sponge/service/model/permissionholder/PermissionHolderSubjectData.java

@@ -65,7 +65,6 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Predicate;
-import java.util.stream.Stream;
 
 public class PermissionHolderSubjectData implements LPSubjectData {
     private final LuckPermsService service;
@@ -81,10 +80,6 @@ public class PermissionHolderSubjectData implements LPSubjectData {
         this.parentSubject = parentSubject;
     }
 
-    private Stream<? extends Node> streamNodes() {
-        return this.holder.getData(this.type).immutable().values().stream();
-    }
-
     @Override
     public SubjectData sponge() {
         return ProxyFactory.toSponge(this);