diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java index 29f28a776..7a29d356c 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java @@ -28,17 +28,19 @@ package me.lucko.luckperms.bukkit.processors; import com.google.common.collect.Maps; import me.lucko.luckperms.api.Tristate; +import me.lucko.luckperms.common.processors.AbstractPermissionProcessor; import me.lucko.luckperms.common.processors.PermissionProcessor; +import java.util.Collections; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * Permission Processor for Bukkits "child" permission system. */ -public class ChildProcessor implements PermissionProcessor { +public class ChildProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private final ChildPermissionProvider provider; - private final Map childPermissions = new ConcurrentHashMap<>(); + private Map childPermissions = Collections.emptyMap(); public ChildProcessor(ChildPermissionProvider provider) { this.provider = provider; @@ -50,13 +52,14 @@ public class ChildProcessor implements PermissionProcessor { } @Override - public void updateBacking(Map map) { - this.childPermissions.clear(); - for (Map.Entry e : map.entrySet()) { + public void refresh() { + Map builder = new ConcurrentHashMap<>(); + for (Map.Entry e : this.sourceMap.entrySet()) { Map children = this.provider.getPermissions().get(Maps.immutableEntry(e.getKey(), e.getValue())); if (children != null) { - this.childPermissions.putAll(children); + builder.putAll(children); } } + this.childPermissions = builder; } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java index 164adbb30..818d13c56 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java @@ -31,8 +31,6 @@ import me.lucko.luckperms.common.processors.PermissionProcessor; import org.bukkit.Bukkit; import org.bukkit.permissions.Permission; -import java.util.Map; - /** * Permission Processor for Bukkits "default" permission system. */ @@ -55,9 +53,4 @@ public class DefaultsProcessor implements PermissionProcessor { Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission); return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(this.isOp)); } - - @Override - public void updateBacking(Map map) { - // Do nothing, this doesn't use the backing - } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java b/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java index d028428b0..1603a08c5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java @@ -72,7 +72,7 @@ public class PermissionCache implements PermissionData { this.permissionsUnmodifiable = Collections.unmodifiableMap(this.permissions); this.calculator = calculatorFactory.build(contexts, metadata); - this.calculator.updateBacking(this.permissions); // Initial setup. + this.calculator.setSourcePermissions(this.permissions); // Initial setup. } @Override @@ -83,7 +83,7 @@ public class PermissionCache implements PermissionData { private void setPermissionsInternal(Map permissions) { this.permissions.clear(); this.permissions.putAll(permissions); - this.calculator.updateBacking(this.permissions); + this.calculator.setSourcePermissions(this.permissions); invalidateCache(); } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java index 83657cd56..edc6e210b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java @@ -44,11 +44,25 @@ import javax.annotation.Nonnull; * Calculates and caches permissions */ public class PermissionCalculator implements CacheLoader { + + /** + * The plugin instance + */ private final LuckPermsPlugin plugin; + + /** + * Info about the nature of this calculator. + */ private final PermissionCalculatorMetadata metadata; + + /** + * The processors which back this calculator + */ private final ImmutableList processors; - // caches lookup calls. + /** + * Loading cache for permission checks + */ private final LoadingCache lookupCache = Caffeine.newBuilder().build(this); public PermissionCalculator(LuckPermsPlugin plugin, PermissionCalculatorMetadata metadata, ImmutableList processors) { @@ -57,16 +71,16 @@ public class PermissionCalculator implements CacheLoader { this.processors = processors; } - public List getProcessors() { - return this.processors; - } - - public void invalidateCache() { - this.lookupCache.invalidateAll(); - } - + /** + * Performs a permission check against this calculator. + * + *

The result is calculated using the calculators backing 'processors'.

+ * + * @param permission the permission to check + * @param origin marks where this check originated from + * @return the result + */ public Tristate getPermissionValue(String permission, CheckOrigin origin) { - // convert the permission to lowercase, as all values in the backing map are also lowercase. // this allows fast case insensitive lookups permission = permission.toLowerCase().intern(); @@ -83,7 +97,6 @@ public class PermissionCalculator implements CacheLoader { @Override public Tristate load(@Nonnull String permission) { - // offer the permission to the permission vault // we only need to do this once per permission, so it doesn't matter // that this call is behind the cache. @@ -91,19 +104,32 @@ public class PermissionCalculator implements CacheLoader { for (PermissionProcessor processor : this.processors) { Tristate result = processor.hasPermission(permission); - if (result == Tristate.UNDEFINED) { - continue; + if (result != Tristate.UNDEFINED) { + return result; } - - return result; } return Tristate.UNDEFINED; } - public synchronized void updateBacking(Map map) { + /** + * Defines the source permissions map which should be used when calculating + * a result. + * + * @param sourceMap the source map + */ + public synchronized void setSourcePermissions(Map sourceMap) { for (PermissionProcessor processor : this.processors) { - processor.updateBacking(map); + processor.setSource(sourceMap); + processor.refresh(); } } + + public List getProcessors() { + return this.processors; + } + + public void invalidateCache() { + this.lookupCache.invalidateAll(); + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java index c023562d4..51b0a2f13 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java @@ -28,6 +28,9 @@ package me.lucko.luckperms.common.calculators; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.common.references.HolderType; +/** + * Metadata about a given {@link PermissionCalculator}. + */ public class PermissionCalculatorMetadata { public static PermissionCalculatorMetadata of(HolderType holderType, String objectName, ContextSet context) { diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java index 0e05e0a26..ae9cf0942 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java @@ -43,20 +43,20 @@ public enum Dependency { ASM( "org.ow2.asm", "asm", - "5.2", - "Pl6g19osUVXvT0cNkJLULeNOP1PbZYnHwH1nIa30uj4=" + "6.0", + "3Ylxx0pOaXiZqOlcquTqh2DqbEhtxrl7F5XnV2BCBGE=" ), ASM_COMMONS( "org.ow2.asm", "asm-commons", - "5.2", - "zBMYiX4sdxy3l6aNX06mQcI6UfBDfKUXq+z5ZN2yZAs=" + "6.0", + "8bzlxkipagF73NAf5dWa+YRSl/17ebgcAVpvu9lxmr8=" ), JAR_RELOCATOR( "me.lucko", "jar-relocator", - "1.2", - "ECR0wrAMwmM0dpmuY1ifCG+2rpObOIlSI127jBbSrbI=" + "1.3", + "mmz3ltQbS8xXGA2scM0ZH6raISlt4nukjCiU2l9Jxfs=" ), CAFFEINE( diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/Relocation.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/Relocation.java index 64366c878..ed248ba26 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/Relocation.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/Relocation.java @@ -29,9 +29,10 @@ import java.util.Arrays; import java.util.List; public final class Relocation { + private static final String RELOCATION_PREFIX = "me.lucko.luckperms.lib."; public static Relocation of(String id, String pattern) { - return new Relocation(pattern.replace("{}", "."), "me.lucko.luckperms.lib." + id); + return new Relocation(pattern.replace("{}", "."), RELOCATION_PREFIX + id); } public static List allOf(Relocation... relocations) { diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/RelocationHandler.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/RelocationHandler.java index ea304e029..e3f328af3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/RelocationHandler.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/relocation/RelocationHandler.java @@ -43,6 +43,8 @@ import java.util.Set; */ public class RelocationHandler { private static final Set DEPENDENCIES = EnumSet.of(Dependency.ASM, Dependency.ASM_COMMONS, Dependency.JAR_RELOCATOR); + private static final String JAR_RELOCATOR_CLASS = "me.lucko.jarrelocator.JarRelocator"; + private static final String JAR_RELOCATOR_RUN_METHOD = "run"; private final Constructor jarRelocatorConstructor; private final Method jarRelocatorRunMethod; @@ -55,13 +57,13 @@ public class RelocationHandler { IsolatedClassLoader classLoader = dependencyManager.obtainClassLoaderWith(DEPENDENCIES); // load the relocator class - Class jarRelocatorClass = classLoader.loadClass("me.lucko.jarrelocator.JarRelocator"); + Class jarRelocatorClass = classLoader.loadClass(JAR_RELOCATOR_CLASS); // prepare the the reflected constructor & method instances this.jarRelocatorConstructor = jarRelocatorClass.getDeclaredConstructor(File.class, File.class, Map.class); this.jarRelocatorConstructor.setAccessible(true); - this.jarRelocatorRunMethod = jarRelocatorClass.getDeclaredMethod("run"); + this.jarRelocatorRunMethod = jarRelocatorClass.getDeclaredMethod(JAR_RELOCATOR_RUN_METHOD); this.jarRelocatorRunMethod.setAccessible(true); } catch (Exception e) { throw new RuntimeException(e); diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java index 9bea72f3a..71a4b8814 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java @@ -51,7 +51,7 @@ public abstract class CachedPrimaryGroupHolder extends StoredHolder implements S protected abstract String calculateValue(); @Override - public String getValue() { + public final String getValue() { String s = this.cache.get(); return s != null ? s : getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME); } diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/AbstractPermissionProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/AbstractPermissionProcessor.java new file mode 100644 index 000000000..c97d64828 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/common/processors/AbstractPermissionProcessor.java @@ -0,0 +1,38 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * 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.processors; + +import java.util.Collections; +import java.util.Map; + +public abstract class AbstractPermissionProcessor implements PermissionProcessor { + protected Map sourceMap = Collections.emptyMap(); + + @Override + public void setSource(Map sourceMap) { + this.sourceMap = sourceMap; + } +} diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java index fe5d9d395..5b3467865 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java @@ -27,20 +27,11 @@ package me.lucko.luckperms.common.processors; import me.lucko.luckperms.api.Tristate; -import java.util.Map; - -public class MapProcessor implements PermissionProcessor { - private Map map = null; +public class MapProcessor extends AbstractPermissionProcessor implements PermissionProcessor { @Override public Tristate hasPermission(String permission) { - return Tristate.fromNullableBoolean(this.map.get(permission)); + return Tristate.fromNullableBoolean(this.sourceMap.get(permission)); } - @Override - public void updateBacking(Map map) { - if (this.map == null) { - this.map = map; - } - } } diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/PermissionProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/PermissionProcessor.java index b24182dbf..7f4a843a3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/PermissionProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/PermissionProcessor.java @@ -26,11 +26,15 @@ package me.lucko.luckperms.common.processors; import me.lucko.luckperms.api.Tristate; +import me.lucko.luckperms.common.calculators.PermissionCalculator; import java.util.Map; /** - * A processor within a {@link me.lucko.luckperms.common.calculators.PermissionCalculator}. + * A processor within a {@link PermissionCalculator}. + * + *

Processors should not implement any sort of caching. This is handled in + * the parent calculator.

*/ public interface PermissionProcessor { @@ -43,14 +47,19 @@ public interface PermissionProcessor { Tristate hasPermission(String permission); /** - * Called each time the permission calculators backing is updated. + * Sets the source permissions which should be used by this processor * - *

Note that the same map instance is passed to this method on each update, - * so, if no processing is needed on the backing map, this can be cached on - * the first invocation.

- * - * @param map the map + * @param sourceMap the source map */ - void updateBacking(Map map); + default void setSource(Map sourceMap) { + + } + + /** + * Called after a change has been made to the source map + */ + default void refresh() { + + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java index 3d02d2857..3ef8b0738 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java @@ -25,15 +25,17 @@ package me.lucko.luckperms.common.processors; +import com.google.common.collect.ImmutableMap; + import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.utils.PatternCache; +import java.util.Collections; import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Pattern; -public class RegexProcessor implements PermissionProcessor { - private final Map regexPermissions = new ConcurrentHashMap<>(); +public class RegexProcessor extends AbstractPermissionProcessor implements PermissionProcessor { + private Map regexPermissions = Collections.emptyMap(); @Override public Tristate hasPermission(String permission) { @@ -47,9 +49,9 @@ public class RegexProcessor implements PermissionProcessor { } @Override - public void updateBacking(Map map) { - this.regexPermissions.clear(); - for (Map.Entry e : map.entrySet()) { + public void refresh() { + ImmutableMap.Builder builder = ImmutableMap.builder(); + for (Map.Entry e : this.sourceMap.entrySet()) { if (!e.getKey().startsWith("r=") && !e.getKey().startsWith("R=")) { continue; } @@ -61,7 +63,8 @@ public class RegexProcessor implements PermissionProcessor { continue; } - this.regexPermissions.put(p, e.getValue()); + builder.put(p, e.getValue()); } + this.regexPermissions = builder.build(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java index 22538c724..ac74fcd58 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java @@ -28,15 +28,11 @@ package me.lucko.luckperms.common.processors; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.node.ImmutableNode; -import java.util.Map; - -public class WildcardProcessor implements PermissionProcessor { +public class WildcardProcessor extends AbstractPermissionProcessor implements PermissionProcessor { public static final String WILDCARD_SUFFIX = ".*"; private static final String GLOBAL_WILDCARD_1 = "*"; private static final String GLOBAL_WILDCARD_2 = "'*'"; - private Map map = null; - @Override public Tristate hasPermission(String permission) { String node = permission; @@ -49,25 +45,19 @@ public class WildcardProcessor implements PermissionProcessor { node = node.substring(0, endIndex); if (!node.isEmpty()) { - Tristate t = Tristate.fromNullableBoolean(this.map.get(node + WILDCARD_SUFFIX)); + Tristate t = Tristate.fromNullableBoolean(this.sourceMap.get(node + WILDCARD_SUFFIX)); if (t != Tristate.UNDEFINED) { return t; } } } - Tristate t = Tristate.fromNullableBoolean(this.map.get(GLOBAL_WILDCARD_1)); + Tristate t = Tristate.fromNullableBoolean(this.sourceMap.get(GLOBAL_WILDCARD_1)); if (t != Tristate.UNDEFINED) { return t; } - return Tristate.fromNullableBoolean(this.map.get(GLOBAL_WILDCARD_2)); + return Tristate.fromNullableBoolean(this.sourceMap.get(GLOBAL_WILDCARD_2)); } - @Override - public void updateBacking(Map map) { - if (this.map == null) { - this.map = map; - } - } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/H2ConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/H2ConnectionFactory.java index 7fe4a6a76..d32120e8f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/H2ConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/H2ConnectionFactory.java @@ -26,12 +26,12 @@ package me.lucko.luckperms.common.storage.dao.sql.connection.file; import me.lucko.luckperms.common.dependencies.Dependency; +import me.lucko.luckperms.common.dependencies.classloader.IsolatedClassLoader; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.io.File; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.net.URLClassLoader; import java.sql.Connection; import java.sql.Driver; import java.sql.SQLException; @@ -55,7 +55,7 @@ public class H2ConnectionFactory extends FlatfileConnectionFactory { } // setup the classloader - URLClassLoader classLoader = plugin.getDependencyManager().obtainClassLoaderWith(EnumSet.of(Dependency.H2_DRIVER)); + IsolatedClassLoader classLoader = plugin.getDependencyManager().obtainClassLoaderWith(EnumSet.of(Dependency.H2_DRIVER)); try { Class driverClass = classLoader.loadClass("org.h2.Driver"); Method loadMethod = driverClass.getMethod("load"); diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/SQLiteConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/SQLiteConnectionFactory.java index 7cbf4980d..57c9e58ab 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/SQLiteConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/SQLiteConnectionFactory.java @@ -26,12 +26,12 @@ package me.lucko.luckperms.common.storage.dao.sql.connection.file; import me.lucko.luckperms.common.dependencies.Dependency; +import me.lucko.luckperms.common.dependencies.classloader.IsolatedClassLoader; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.io.File; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.net.URLClassLoader; import java.sql.Connection; import java.sql.SQLException; import java.util.EnumSet; @@ -54,7 +54,7 @@ public class SQLiteConnectionFactory extends FlatfileConnectionFactory { } // setup the classloader - URLClassLoader classLoader = plugin.getDependencyManager().obtainClassLoaderWith(EnumSet.of(Dependency.SQLITE_DRIVER)); + IsolatedClassLoader classLoader = plugin.getDependencyManager().obtainClassLoaderWith(EnumSet.of(Dependency.SQLITE_DRIVER)); try { Class jdcbClass = classLoader.loadClass("org.sqlite.JDBC"); this.createConnectionMethod = jdcbClass.getMethod("createConnection", String.class, Properties.class); diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/HttpClient.java b/common/src/main/java/me/lucko/luckperms/common/utils/HttpClient.java index 686cc2b75..532eb29af 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/HttpClient.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/HttpClient.java @@ -50,7 +50,7 @@ public class HttpClient { return response; } - public static RuntimeException exceptionForUnsuccessfulResponse(Response response) { + private static RuntimeException exceptionForUnsuccessfulResponse(Response response) { String msg = ""; try (ResponseBody responseBody = response.body()) { if (responseBody != null) { diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/DefaultsProcessor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/DefaultsProcessor.java index d03622b7b..77530e001 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/DefaultsProcessor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/DefaultsProcessor.java @@ -31,8 +31,6 @@ import me.lucko.luckperms.common.processors.PermissionProcessor; import me.lucko.luckperms.sponge.service.LuckPermsService; import me.lucko.luckperms.sponge.service.model.LPSubject; -import java.util.Map; - public abstract class DefaultsProcessor implements PermissionProcessor { private final LuckPermsService service; private final ImmutableContextSet contexts; @@ -58,9 +56,4 @@ public abstract class DefaultsProcessor implements PermissionProcessor { return Tristate.UNDEFINED; } - - @Override - public void updateBacking(Map map) { - // Do nothing, this doesn't use the backing - } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java index 33f1c6bbb..daee7809c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java @@ -27,12 +27,10 @@ package me.lucko.luckperms.sponge.processors; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.node.ImmutableNode; +import me.lucko.luckperms.common.processors.AbstractPermissionProcessor; import me.lucko.luckperms.common.processors.PermissionProcessor; -import java.util.Map; - -public class SpongeWildcardProcessor implements PermissionProcessor { - private Map map = null; +public class SpongeWildcardProcessor extends AbstractPermissionProcessor implements PermissionProcessor { @Override public Tristate hasPermission(String permission) { @@ -46,7 +44,7 @@ public class SpongeWildcardProcessor implements PermissionProcessor { node = node.substring(0, endIndex); if (!node.isEmpty()) { - Tristate t = Tristate.fromNullableBoolean(this.map.get(node)); + Tristate t = Tristate.fromNullableBoolean(this.sourceMap.get(node)); if (t != Tristate.UNDEFINED) { return t; } @@ -56,10 +54,4 @@ public class SpongeWildcardProcessor implements PermissionProcessor { return Tristate.UNDEFINED; } - @Override - public void updateBacking(Map map) { - if (this.map == null) { - this.map = map; - } - } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java index ca99acb59..6b4e048ed 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java @@ -330,13 +330,13 @@ public class CalculatedSubjectData implements LPSubjectData { public CalculatorHolder(PermissionCalculator calculator) { this.calculator = calculator; this.permissions = new ConcurrentHashMap<>(); - this.calculator.updateBacking(this.permissions); + this.calculator.setSourcePermissions(this.permissions); } public void setPermissions(Map permissions) { this.permissions.clear(); this.permissions.putAll(permissions); - this.calculator.updateBacking(this.permissions); + this.calculator.setSourcePermissions(this.permissions); this.calculator.invalidateCache(); }