Sponge: replace MemorySubjectData with own implementation

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCalculatorFactory.java

@@ -30,7 +30,7 @@ import me.lucko.luckperms.bukkit.calculators.ChildProcessor;
 import me.lucko.luckperms.bukkit.calculators.DefaultsProcessor;
 import me.lucko.luckperms.bukkit.inject.Injector;
 import me.lucko.luckperms.bukkit.model.LPPermissible;
-import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
 import me.lucko.luckperms.common.calculators.PermissionCalculator;
 import me.lucko.luckperms.common.calculators.PermissionProcessor;
 import me.lucko.luckperms.common.calculators.processors.MapProcessor;
@@ -41,7 +41,7 @@ import me.lucko.luckperms.common.core.model.User;
 import java.util.UUID;
 
 @AllArgsConstructor
-public class BukkitCalculatorFactory implements CalculatorFactory {
+public class BukkitCalculatorFactory extends AbstractCalculatorFactory {
     private final LPBukkitPlugin plugin;
 
     @Override
@@ -63,6 +63,6 @@ public class BukkitCalculatorFactory implements CalculatorFactory {
         }
         processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider()));
 
-        return new PermissionCalculator(plugin, user.getName(), processors.build());
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
     }
 }

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCalculatorFactory.java

@@ -25,7 +25,7 @@ package me.lucko.luckperms.bungee;
 import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.api.Contexts;
-import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
 import me.lucko.luckperms.common.calculators.PermissionCalculator;
 import me.lucko.luckperms.common.calculators.PermissionProcessor;
 import me.lucko.luckperms.common.calculators.processors.MapProcessor;
@@ -34,7 +34,7 @@ import me.lucko.luckperms.common.calculators.processors.WildcardProcessor;
 import me.lucko.luckperms.common.core.model.User;
 
 @AllArgsConstructor
-public class BungeeCalculatorFactory implements CalculatorFactory {
+public class BungeeCalculatorFactory extends AbstractCalculatorFactory {
     private final LPBungeePlugin plugin;
 
     @Override
@@ -48,6 +48,6 @@ public class BungeeCalculatorFactory implements CalculatorFactory {
             processors.add(new RegexProcessor());
         }
 
-        return new PermissionCalculator(plugin, user.getName(), processors.build());
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
     }
 }

common/src/main/java/me/lucko/luckperms/common/calculators/AbstractCalculatorFactory.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  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.calculators;
+
+import com.google.common.collect.MapMaker;
+
+import java.util.Collections;
+import java.util.Set;
+
+public abstract class AbstractCalculatorFactory implements CalculatorFactory {
+    private final Set<PermissionCalculator> calculators = Collections.newSetFromMap(new MapMaker().weakKeys().makeMap());
+
+    protected PermissionCalculator registerCalculator(PermissionCalculator calculator) {
+        calculators.add(calculator);
+        return calculator;
+    }
+
+    @Override
+    public void invalidateAll() {
+        for (PermissionCalculator calculator : calculators) {
+            calculator.invalidateCache();
+        }
+    }
+}

common/src/main/java/me/lucko/luckperms/common/calculators/CalculatorFactory.java

@@ -30,6 +30,17 @@ import me.lucko.luckperms.common.core.model.User;
  */
 public interface CalculatorFactory {
 
+    /**
+     * Builds a PermissionCalculator for the user in the given context
+     * @param contexts the contexts to build the calculator in
+     * @param user the user to build for
+     * @return a permission calculator instance
+     */
     PermissionCalculator build(Contexts contexts, User user);
 
+    /**
+     * Invalidates all calculators build by this factory
+     */
+    void invalidateAll();
+
 }

sponge/src/main/java/me/lucko/luckperms/sponge/SpongeCalculatorFactory.java

@@ -25,7 +25,7 @@ package me.lucko.luckperms.sponge;
 import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.api.Contexts;
-import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
 import me.lucko.luckperms.common.calculators.PermissionCalculator;
 import me.lucko.luckperms.common.calculators.PermissionProcessor;
 import me.lucko.luckperms.common.calculators.processors.MapProcessor;
@@ -37,7 +37,7 @@ import me.lucko.luckperms.sponge.calculators.SpongeWildcardProcessor;
 import me.lucko.luckperms.sponge.service.LuckPermsService;
 
 @AllArgsConstructor
-public class SpongeCalculatorFactory implements CalculatorFactory {
+public class SpongeCalculatorFactory extends AbstractCalculatorFactory {
     private final LPSpongePlugin plugin;
 
     @Override
@@ -53,6 +53,6 @@ public class SpongeCalculatorFactory implements CalculatorFactory {
         }
         processors.add(new DefaultsProcessor(plugin.getService(), LuckPermsService.convertContexts(contexts.getContexts())));
 
-        return new PermissionCalculator(plugin, user.getName(), processors.build());
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
     }
 }

sponge/src/main/java/me/lucko/luckperms/sponge/service/data/CalculatedSubjectData.java

@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  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.sponge.service.data;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMap;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import me.lucko.luckperms.common.calculators.PermissionCalculator;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import me.lucko.luckperms.common.calculators.processors.MapProcessor;
+import me.lucko.luckperms.common.utils.ImmutableCollectors;
+import me.lucko.luckperms.sponge.calculators.SpongeWildcardProcessor;
+import me.lucko.luckperms.sponge.service.LuckPermsService;
+import org.spongepowered.api.service.context.Context;
+import org.spongepowered.api.service.permission.Subject;
+import org.spongepowered.api.service.permission.SubjectData;
+import org.spongepowered.api.util.Tristate;
+
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class CalculatedSubjectData implements SubjectData {
+    private static final ContextComparator CONTEXT_COMPARATOR = new ContextComparator();
+
+    private final LuckPermsService service;
+    private final String calculatorDisplayName;
+
+    private final LoadingCache<Set<Context>, CalculatorHolder> permissionCache = CacheBuilder.newBuilder()
+            .build(new CacheLoader<Set<Context>, CalculatorHolder>() {
+                @Override
+                public CalculatorHolder load(Set<Context> contexts) {
+                    ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+                    processors.add(new MapProcessor());
+                    processors.add(new SpongeWildcardProcessor());
+
+                    CalculatorHolder holder = new CalculatorHolder(new PermissionCalculator(service.getPlugin(), calculatorDisplayName, processors.build()));
+                    holder.setPermissions(flattenMap(contexts, permissions));
+
+                    return holder;
+                }
+            });
+
+    private final LoadingCache<Set<Context>, Map<String, String>> optionCache = CacheBuilder.newBuilder()
+            .build(new CacheLoader<Set<Context>, Map<String, String>>() {
+                @Override
+                public Map<String, String> load(Set<Context> contexts) {
+                    return flattenMap(contexts, options);
+                }
+            });
+
+    private final Map<Set<Context>, Map<String, Boolean>> permissions = new ConcurrentHashMap<>();
+    private final Map<Set<Context>, Set<SubjectReference>> parents = new ConcurrentHashMap<>();
+    private final Map<Set<Context>, Map<String, String>> options = new ConcurrentHashMap<>();
+
+    public Tristate getPermissionValue(Set<Context> contexts, String permission) {
+        return LuckPermsService.convertTristate(permissionCache.getUnchecked(contexts).getCalculator().getPermissionValue(permission));
+    }
+
+    public Map<Set<Context>, Set<SubjectReference>> getParents() {
+        ImmutableMap.Builder<Set<Context>, Set<SubjectReference>> map = ImmutableMap.builder();
+        for (Map.Entry<Set<Context>, Set<SubjectReference>> e : parents.entrySet()) {
+            map.put(ImmutableSet.copyOf(e.getKey()), ImmutableSet.copyOf(e.getValue()));
+        }
+        return map.build();
+    }
+
+    public void replacePermissions(Map<Set<Context>, Map<String, Boolean>> map) {
+        permissions.clear();
+        for (Map.Entry<Set<Context>, Map<String, Boolean>> e : map.entrySet()) {
+            permissions.put(ImmutableSet.copyOf(e.getKey()), new ConcurrentHashMap<>(e.getValue()));
+        }
+        permissionCache.invalidateAll();
+    }
+
+    public void replaceParents(Map<Set<Context>, Set<SubjectReference>> map) {
+        parents.clear();
+        for (Map.Entry<Set<Context>, Set<SubjectReference>> e : map.entrySet()) {
+            Set<SubjectReference> set = ConcurrentHashMap.newKeySet();
+            set.addAll(e.getValue());
+            parents.put(ImmutableSet.copyOf(e.getKey()), set);
+        }
+    }
+
+    public void replaceOptions(Map<Set<Context>, Map<String, String>> map) {
+        options.clear();
+        for (Map.Entry<Set<Context>, Map<String, String>> e : map.entrySet()) {
+            options.put(ImmutableSet.copyOf(e.getKey()), new ConcurrentHashMap<>(e.getValue()));
+        }
+        optionCache.invalidateAll();
+    }
+
+    @Override
+    public Map<Set<Context>, Map<String, Boolean>> getAllPermissions() {
+        ImmutableMap.Builder<Set<Context>, Map<String, Boolean>> map = ImmutableMap.builder();
+        for (Map.Entry<Set<Context>, Map<String, Boolean>> e : permissions.entrySet()) {
+            map.put(ImmutableSet.copyOf(e.getKey()), ImmutableMap.copyOf(e.getValue()));
+        }
+        return map.build();
+    }
+
+    @Override
+    public Map<String, Boolean> getPermissions(Set<Context> contexts) {
+        return ImmutableMap.copyOf(permissions.getOrDefault(contexts, ImmutableMap.of()));
+    }
+
+    @Override
+    public boolean setPermission(Set<Context> contexts, String permission, Tristate value) {
+        boolean b;
+        if (value == Tristate.UNDEFINED) {
+            Map<String, Boolean> perms = permissions.get(contexts);
+            b = perms != null && perms.remove(permission.toLowerCase()) != null;
+        } else {
+            Map<String, Boolean> perms = permissions.computeIfAbsent(ImmutableSet.copyOf(contexts), c -> new ConcurrentHashMap<>());
+            b = !Objects.equals(perms.put(permission.toLowerCase(), value.asBoolean()), value.asBoolean());
+        }
+        if (b) {
+            permissionCache.invalidateAll();
+        }
+        return b;
+    }
+
+    @Override
+    public boolean clearPermissions() {
+        if (permissions.isEmpty()) {
+            return false;
+        } else {
+            permissions.clear();
+            permissionCache.invalidateAll();
+            return true;
+        }
+    }
+
+    @Override
+    public boolean clearPermissions(Set<Context> contexts) {
+        Map<String, Boolean> perms = permissions.get(contexts);
+        if (perms == null) {
+            return false;
+        }
+
+        permissions.remove(contexts);
+        if (!perms.isEmpty()) {
+            permissionCache.invalidateAll();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Map<Set<Context>, List<Subject>> getAllParents() {
+        ImmutableMap.Builder<Set<Context>, List<Subject>> map = ImmutableMap.builder();
+        for (Map.Entry<Set<Context>, Set<SubjectReference>> e : parents.entrySet()) {
+            map.put(
+                    ImmutableSet.copyOf(e.getKey()),
+                    e.getValue().stream().map(s -> s.resolve(service)).collect(ImmutableCollectors.toImmutableList())
+            );
+        }
+        return map.build();
+    }
+
+    @Override
+    public List<Subject> getParents(Set<Context> contexts) {
+        return parents.getOrDefault(contexts, ImmutableSet.of()).stream()
+                .map(s -> s.resolve(service))
+                .collect(ImmutableCollectors.toImmutableList());
+    }
+
+    @Override
+    public boolean addParent(Set<Context> contexts, Subject parent) {
+        Set<SubjectReference> set = parents.computeIfAbsent(ImmutableSet.copyOf(contexts), c -> ConcurrentHashMap.newKeySet());
+        return set.add(SubjectReference.of(parent));
+    }
+
+    @Override
+    public boolean removeParent(Set<Context> contexts, Subject parent) {
+        Set<SubjectReference> set = parents.get(contexts);
+        return set != null && set.remove(SubjectReference.of(parent));
+    }
+
+    @Override
+    public boolean clearParents() {
+        if (parents.isEmpty()) {
+            return false;
+        } else {
+            parents.clear();
+            return true;
+        }
+    }
+
+    @Override
+    public boolean clearParents(Set<Context> contexts) {
+        Set<SubjectReference> set = parents.get(contexts);
+        if (set == null) {
+            return false;
+        }
+
+        parents.remove(contexts);
+        return !set.isEmpty();
+    }
+
+    @Override
+    public Map<Set<Context>, Map<String, String>> getAllOptions() {
+        ImmutableMap.Builder<Set<Context>, Map<String, String>> map = ImmutableMap.builder();
+        for (Map.Entry<Set<Context>, Map<String, String>> e : options.entrySet()) {
+            map.put(ImmutableSet.copyOf(e.getKey()), ImmutableMap.copyOf(e.getValue()));
+        }
+        return map.build();
+    }
+
+    @Override
+    public Map<String, String> getOptions(Set<Context> contexts) {
+        return ImmutableMap.copyOf(options.getOrDefault(contexts, ImmutableMap.of()));
+    }
+
+    @Override
+    public boolean setOption(Set<Context> contexts, String key, @Nullable String value) {
+        boolean b;
+        if (value == null) {
+            Map<String, String> options = this.options.get(contexts);
+            b = options != null && options.remove(key.toLowerCase()) != null;
+        } else {
+            Map<String, String> options = this.options.computeIfAbsent(ImmutableSet.copyOf(contexts), c -> new ConcurrentHashMap<>());
+            b = !stringEquals(options.put(key.toLowerCase(), value), value);
+        }
+        if (b) {
+            optionCache.invalidateAll();
+        }
+        return b;
+    }
+
+    @Override
+    public boolean clearOptions() {
+        if (options.isEmpty()) {
+            return false;
+        } else {
+            options.clear();
+            optionCache.invalidateAll();
+            return true;
+        }
+    }
+
+    @Override
+    public boolean clearOptions(Set<Context> contexts) {
+        Map<String, String> map = options.get(contexts);
+        if (map == null) {
+            return false;
+        }
+
+        options.remove(contexts);
+        if (!map.isEmpty()) {
+            optionCache.invalidateAll();
+            return true;
+        }
+        return false;
+    }
+
+    private static <V> Map<String, V> flattenMap(Set<Context> contexts, Map<Set<Context>, Map<String, V>> source) {
+        Map<String, V> map = new HashMap<>();
+
+        SortedMap<Set<Context>, Map<String, V>> ret = getRelevantEntries(contexts, source);
+        for (Map<String, V> m : ret.values()) {
+            for (Map.Entry<String, V> e : m.entrySet()) {
+                if (!map.containsKey(e.getKey())) {
+                    map.put(e.getKey(), e.getValue());
+                }
+            }
+        }
+
+        return ImmutableMap.copyOf(map);
+    }
+
+    private static <K, V> SortedMap<Set<Context>, Map<K, V>> getRelevantEntries(Set<Context> set, Map<Set<Context>, Map<K, V>> map) {
+        ImmutableSortedMap.Builder<Set<Context>, Map<K, V>> perms = ImmutableSortedMap.orderedBy(CONTEXT_COMPARATOR);
+
+        loop:
+        for (Map.Entry<Set<Context>, Map<K, V>> e : map.entrySet()) {
+            for (Context c : e.getKey()) {
+                if (!set.contains(c)) {
+                    continue loop;
+                }
+            }
+
+            perms.put(ImmutableSet.copyOf(e.getKey()), ImmutableMap.copyOf(e.getValue()));
+        }
+
+        return perms.build();
+    }
+
+    private static boolean stringEquals(String a, String b) {
+        return a == null && b == null || a != null && b != null && a.equalsIgnoreCase(b);
+    }
+
+    private static class ContextComparator implements Comparator<Set<Context>> {
+
+        @Override
+        public int compare(Set<Context> o1, Set<Context> o2) {
+            int i = Integer.compare(o1.size(), o2.size());
+            return i == 0 ? 1 : i;
+        }
+    }
+
+    private static class CalculatorHolder {
+
+        @Getter
+        private final PermissionCalculator calculator;
+
+        @Getter
+        private final Map<String, Boolean> permissions;
+
+        public CalculatorHolder(PermissionCalculator calculator) {
+            this.calculator = calculator;
+            this.permissions = new ConcurrentHashMap<>();
+            this.calculator.updateBacking(permissions);
+        }
+
+        public void setPermissions(Map<String, Boolean> permissions) {
+            this.permissions.clear();
+            this.permissions.putAll(permissions);
+            calculator.updateBacking(this.permissions);
+            calculator.invalidateCache();
+        }
+    }
+}

sponge/src/main/java/me/lucko/luckperms/sponge/service/data/SubjectReference.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  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.sponge.service.data;
+
+import com.google.common.base.Splitter;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.ToString;
+import org.spongepowered.api.service.permission.PermissionService;
+import org.spongepowered.api.service.permission.Subject;
+
+import java.util.List;
+
+@Getter
+@ToString
+@EqualsAndHashCode
+@AllArgsConstructor(staticName = "of")
+public class SubjectReference {
+    public static SubjectReference deserialize(String s) {
+        List<String> parts = Splitter.on('/').limit(2).splitToList(s);
+        return of(parts.get(0), parts.get(1));
+    }
+
+    public static SubjectReference of(Subject subject) {
+        return of(subject.getContainingCollection().getIdentifier(), subject.getIdentifier());
+    }
+
+    private final String collection;
+    private final String identifier;
+
+    public Subject resolve(PermissionService service) {
+        return service.getSubjects(collection).get(identifier);
+    }
+
+    public String serialize() {
+        return collection + "/" + identifier;
+    }
+
+}

sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java

@@ -29,10 +29,10 @@ import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.common.utils.BufferedRequest;
 import me.lucko.luckperms.sponge.service.LuckPermsService;
+import me.lucko.luckperms.sponge.service.data.CalculatedSubjectData;
 import me.lucko.luckperms.sponge.timings.LPTiming;
 import org.spongepowered.api.command.CommandSource;
 import org.spongepowered.api.service.context.Context;
-import org.spongepowered.api.service.permission.MemorySubjectData;
 import org.spongepowered.api.service.permission.Subject;
 import org.spongepowered.api.util.Tristate;
 
@@ -52,7 +52,7 @@ public class PersistedSubject implements Subject {
     private final LuckPermsService service;
     private final PersistedCollection containingCollection;
     private final PersistedSubjectData subjectData;
-    private final MemorySubjectData transientSubjectData;
+    private final CalculatedSubjectData transientSubjectData;
     private final BufferedRequest<Void> saveBuffer = new BufferedRequest<Void>(1000L, r -> PersistedSubject.this.service.getPlugin().doAsync(r)) {
         @Override
         protected Void perform() {
@@ -71,13 +71,13 @@ public class PersistedSubject implements Subject {
         this.identifier = identifier;
         this.service = service;
         this.containingCollection = containingCollection;
-        this.subjectData = new PersistedSubjectData(service, this);
+        this.subjectData = new PersistedSubjectData(service, "local:" + containingCollection.getIdentifier() + "/" + identifier + "(p)", this);
-        this.transientSubjectData = new MemorySubjectData(service);
+        this.transientSubjectData = new CalculatedSubjectData(service, "local:" + containingCollection.getIdentifier() + "/" + identifier + "(t)");
     }
 
     public void loadData(SubjectDataHolder dataHolder) {
         subjectData.setSave(false);
-        dataHolder.copyTo(subjectData, service);
+        dataHolder.copyTo(subjectData);
         subjectData.setSave(true);
     }
 
@@ -98,12 +98,12 @@ public class PersistedSubject implements Subject {
     @Override
     public Tristate getPermissionValue(@NonNull Set<Context> contexts, @NonNull String node) {
         try (Timing ignored = service.getPlugin().getTimings().time(LPTiming.PERSISTED_SUBJECT_GET_PERMISSION_VALUE)) {
-            Tristate res = subjectData.getNodeTree(contexts).get(node);
+            Tristate res = subjectData.getPermissionValue(contexts, node);
             if (res != Tristate.UNDEFINED) {
                 return res;
             }
 
-            res = transientSubjectData.getNodeTree(contexts).get(node);
+            res = transientSubjectData.getPermissionValue(contexts, node);
             if (res != Tristate.UNDEFINED) {
                 return res;
             }

sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubjectData.java

@@ -24,9 +24,9 @@ package me.lucko.luckperms.sponge.service.persisted;
 
 import lombok.Getter;
 import lombok.Setter;
+import me.lucko.luckperms.sponge.service.LuckPermsService;
+import me.lucko.luckperms.sponge.service.data.CalculatedSubjectData;
 import org.spongepowered.api.service.context.Context;
-import org.spongepowered.api.service.permission.MemorySubjectData;
-import org.spongepowered.api.service.permission.PermissionService;
 import org.spongepowered.api.service.permission.Subject;
 import org.spongepowered.api.util.Tristate;
 
@@ -36,15 +36,15 @@ import java.util.Set;
 /**
  * Extension of MemorySubjectData which persists data when modified
  */
-public class PersistedSubjectData extends MemorySubjectData {
+public class PersistedSubjectData extends CalculatedSubjectData {
     private final PersistedSubject subject;
 
     @Getter
     @Setter
     private boolean save = true;
 
-    public PersistedSubjectData(PermissionService service, PersistedSubject subject) {
+    public PersistedSubjectData(LuckPermsService service, String calculatorDisplayName, PersistedSubject subject) {
-        super(service);
+        super(service, calculatorDisplayName);
         this.subject = subject;
     }
 

sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/SubjectDataHolder.java

@@ -22,15 +22,16 @@
 
 package me.lucko.luckperms.sponge.service.persisted;
 
-import com.google.common.base.Splitter;
 import lombok.ToString;
 import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.sponge.service.data.CalculatedSubjectData;
+import me.lucko.luckperms.sponge.service.data.SubjectReference;
 import org.spongepowered.api.service.context.Context;
-import org.spongepowered.api.service.permission.MemorySubjectData;
-import org.spongepowered.api.service.permission.PermissionService;
-import org.spongepowered.api.util.Tristate;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import static me.lucko.luckperms.sponge.service.LuckPermsService.convertContexts;
@@ -44,7 +45,7 @@ public class SubjectDataHolder {
     private final Map<Map<String, String>, Map<String, String>> options;
     private final Map<Map<String, String>, List<String>> parents;
 
-    public SubjectDataHolder(Map<Set<Context>, Map<String, String>> options, Map<Set<Context>, Map<String, Boolean>> permissions, Map<Set<Context>, List<Map.Entry<String, String>>> parents) {
+    public SubjectDataHolder(Map<Set<Context>, Map<String, String>> options, Map<Set<Context>, Map<String, Boolean>> permissions, Map<Set<Context>, Set<SubjectReference>> parents) {
         this.options = new HashMap<>();
         for (Map.Entry<Set<Context>, Map<String, String>> e : options.entrySet()) {
             this.options.put(convertContexts(e.getKey()).toMap(), new HashMap<>(e.getValue()));
@@ -56,50 +57,35 @@ public class SubjectDataHolder {
         }
 
         this.parents = new HashMap<>();
-        for (Map.Entry<Set<Context>, List<Map.Entry<String, String>>> e : parents.entrySet()) {
+        for (Map.Entry<Set<Context>, Set<SubjectReference>> e : parents.entrySet()) {
-            this.parents.put(convertContexts(e.getKey()).toMap(), e.getValue().stream().map(p -> p.getKey() + "/" + p.getValue()).collect(Collectors.toList()));
+            this.parents.put(convertContexts(e.getKey()).toMap(), e.getValue().stream().map(SubjectReference::serialize).collect(Collectors.toList()));
         }
     }
 
-    public SubjectDataHolder(MemorySubjectData data) {
+    public SubjectDataHolder(CalculatedSubjectData data) {
-        this(
+        this(data.getAllOptions(), data.getAllPermissions(), data.getParents());
-                data.getAllOptions(),
+    }
-                data.getAllPermissions(),
+
-                data.getAllParents().entrySet().stream()
+    public void copyTo(CalculatedSubjectData subjectData) {
+        subjectData.replacePermissions(permissions.entrySet().stream()
                 .collect(Collectors.toMap(
-                                Map.Entry::getKey,
+                        k -> convertContexts(ContextSet.fromMap(k.getKey())),
-                                e -> e.getValue().stream()
+                        Map.Entry::getValue
-                                        .map(s -> new AbstractMap.SimpleEntry<>(
+                ))
-                                                s.getContainingCollection().getIdentifier(),
+        );
-                                                s.getIdentifier())
+
-                                        )
+        subjectData.replaceOptions(options.entrySet().stream()
-                                        .collect(Collectors.toList())
+                .collect(Collectors.toMap(
-                                )
+                        k -> convertContexts(ContextSet.fromMap(k.getKey())),
-                        )
+                        Map.Entry::getValue
+                ))
+        );
+
+        subjectData.replaceParents(parents.entrySet().stream()
+                .collect(Collectors.toMap(
+                        k -> convertContexts(ContextSet.fromMap(k.getKey())),
+                        v -> v.getValue().stream().map(SubjectReference::deserialize).collect(Collectors.toSet())
+                ))
         );
     }
-
-    public void copyTo(MemorySubjectData subjectData, PermissionService service) {
-        for (Map.Entry<Map<String, String>, Map<String, Boolean>> e : permissions.entrySet()) {
-            Set<Context> contexts = convertContexts(ContextSet.fromMap(e.getKey()));
-            for (Map.Entry<String, Boolean> perm : e.getValue().entrySet()) {
-                subjectData.setPermission(contexts, perm.getKey(), Tristate.fromBoolean(perm.getValue()));
-            }
-        }
-
-        for (Map.Entry<Map<String, String>, Map<String, String>> e : options.entrySet()) {
-            Set<Context> contexts = convertContexts(ContextSet.fromMap(e.getKey()));
-            for (Map.Entry<String, String> option : e.getValue().entrySet()) {
-                subjectData.setOption(contexts, option.getKey(), option.getValue());
-            }
-        }
-
-        for (Map.Entry<Map<String, String>, List<String>> e : parents.entrySet()) {
-            Set<Context> contexts = convertContexts(ContextSet.fromMap(e.getKey()));
-            for (String parent : e.getValue()) {
-                List<String> parts = Splitter.on('/').limit(2).splitToList(parent);
-                subjectData.addParent(contexts, service.getSubjects(parts.get(0)).get(parts.get(1)));
-            }
-        }
-    }
 }

sponge/src/main/java/me/lucko/luckperms/sponge/service/simple/SimpleSubject.java

@@ -28,12 +28,11 @@ import com.google.common.collect.ImmutableSet;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.sponge.service.LuckPermsService;
+import me.lucko.luckperms.sponge.service.data.CalculatedSubjectData;
 import me.lucko.luckperms.sponge.timings.LPTiming;
 import org.spongepowered.api.command.CommandSource;
 import org.spongepowered.api.service.context.Context;
-import org.spongepowered.api.service.permission.MemorySubjectData;
 import org.spongepowered.api.service.permission.Subject;
-import org.spongepowered.api.service.permission.SubjectData;
 import org.spongepowered.api.util.Tristate;
 
 import java.util.ArrayList;
@@ -50,13 +49,15 @@ public class SimpleSubject implements Subject {
 
     private final LuckPermsService service;
     private final SimpleCollection containingCollection;
-    private final MemorySubjectData subjectData;
+    private final CalculatedSubjectData subjectData;
+    private final CalculatedSubjectData transientSubjectData;
 
     public SimpleSubject(String identifier, LuckPermsService service, SimpleCollection containingCollection) {
         this.identifier = identifier;
         this.service = service;
         this.containingCollection = containingCollection;
-        this.subjectData = new MemorySubjectData(service);
+        this.subjectData = new CalculatedSubjectData(service, "local:" + containingCollection.getIdentifier() + "/" + identifier + "(p)");
+        this.transientSubjectData = new CalculatedSubjectData(service, "local:" + containingCollection.getIdentifier() + "/" + identifier + "(t)");
     }
 
     @Override
@@ -64,11 +65,6 @@ public class SimpleSubject implements Subject {
         return Optional.empty();
     }
 
-    @Override
-    public SubjectData getTransientSubjectData() {
-        return getSubjectData();
-    }
-
     @Override
     public boolean hasPermission(@NonNull Set<Context> contexts, @NonNull String node) {
         return getPermissionValue(contexts, node).asBoolean();
@@ -77,15 +73,20 @@ public class SimpleSubject implements Subject {
     @Override
     public Tristate getPermissionValue(@NonNull Set<Context> contexts, @NonNull String node) {
         try (Timing ignored = service.getPlugin().getTimings().time(LPTiming.SIMPLE_SUBJECT_GET_PERMISSION_VALUE)) {
-            Tristate res = subjectData.getNodeTree(contexts).get(node);
+            Tristate res = transientSubjectData.getPermissionValue(contexts, node);
+            if (res != Tristate.UNDEFINED) {
+                return res;
+            }
+
+            res = subjectData.getPermissionValue(contexts, node);
             if (res != Tristate.UNDEFINED) {
                 return res;
             }
 
             for (Subject parent : getParents(contexts)) {
-                Tristate tempRes = parent.getPermissionValue(contexts, node);
+                res = parent.getPermissionValue(contexts, node);
-                if (tempRes != Tristate.UNDEFINED) {
+                if (res != Tristate.UNDEFINED) {
-                    return tempRes;
+                    return res;
                 }
             }
 
@@ -93,7 +94,7 @@ public class SimpleSubject implements Subject {
                 return Tristate.UNDEFINED;
             }
 
-            res = service.getGroupSubjects().getDefaults().getPermissionValue(contexts, node);
+            res = getContainingCollection().getDefaults().getPermissionValue(contexts, node);
             if (res != Tristate.UNDEFINED) {
                 return res;
             }