Properly implement Contexts#allowAll - bump API to 3.3

api/src/main/java/me/lucko/luckperms/api/Contexts.java

@@ -39,16 +39,28 @@ import javax.annotation.Nonnull;
 public class Contexts {
     public static final String SERVER_KEY = "server";
     public static final String WORLD_KEY = "world";
-    private static final Contexts ALLOW_ALL = new Contexts(ContextSet.empty(), true, true, true, true, true, true);
+
+    private static final Contexts GLOBAL = new Contexts(ContextSet.empty(), true, true, true, true, true, false);
 
     /**
-     * Gets a context that will allow all nodes
+     * Gets the {@link FullySatisfiedContexts} instance.
      *
-     * @return a context that will not apply any filters
+     * @return a context that will satisfy all contextual requirements.
      */
     @Nonnull
     public static Contexts allowAll() {
-        return ALLOW_ALL;
+        return FullySatisfiedContexts.getInstance();
+    }
+
+    /**
+     * A contexts instance with no defined context.
+     *
+     * @return the global contexts
+     * @since 3.3
+     */
+    @Nonnull
+    public static Contexts global() {
+        return GLOBAL;
     }
 
     public static Contexts of(@Nonnull ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
@@ -193,7 +205,9 @@ public class Contexts {
     @Override
     public boolean equals(Object o) {
         if (o == this) return true;
+        if (o == allowAll()) return false;
         if (!(o instanceof Contexts)) return false;
+
         final Contexts other = (Contexts) o;
         return this.getContexts().equals(other.getContexts()) &&
                 this.isOp() == other.isOp() &&
@@ -209,7 +223,7 @@ public class Contexts {
         final int PRIME = 59;
         int result = 1;
         final Object contexts = this.getContexts();
-        result = result * PRIME + (contexts == null ? 43 : contexts.hashCode());
+        result = result * PRIME + contexts.hashCode();
         result = result * PRIME + (this.isOp() ? 79 : 97);
         result = result * PRIME + (this.isIncludeGlobal() ? 79 : 97);
         result = result * PRIME + (this.isIncludeGlobalWorld() ? 79 : 97);

api/src/main/java/me/lucko/luckperms/api/FullySatisfiedContexts.java

@@ -0,0 +1,51 @@
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.caching.MetaContexts;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.context.ContextSet;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A special instance of {@link Contexts}, which when passed to:
+ *
+ * <p><ul>
+ * <li>{@link UserData#getPermissionData(Contexts)}</li>
+ * <li>{@link UserData#getMetaData(Contexts)}</li>
+ * <li>{@link UserData#getMetaData(MetaContexts)}</li>
+ * </ul></p>
+ *
+ * <p>will always satisfy all contextual requirements.</p>
+ *
+ * <p>This effectively allows you to do lookups which ignore context.</p>
+ *
+ * @since 3.3
+ */
+public final class FullySatisfiedContexts extends Contexts {
+    private static final FullySatisfiedContexts INSTANCE = new FullySatisfiedContexts();
+
+    @Nonnull
+    public static Contexts getInstance() {
+        return INSTANCE;
+    }
+
+    private FullySatisfiedContexts() {
+        super(ContextSet.empty(), true, true, true, true, true, false);
+    }
+
+    @Nonnull
+    @Override
+    public String toString() {
+        return "FullySatisfiedContexts";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o == this;
+    }
+
+    @Override
+    public int hashCode() {
+        return System.identityHashCode(this);
+    }
+}

api/src/main/java/me/lucko/luckperms/api/LPConfiguration.java

@@ -173,4 +173,24 @@ public interface LPConfiguration {
     @Nonnull
     Map<String, String> getSplitStorageOptions();
 
+    @Nonnull
+    Unsafe unsafe();
+
+    interface Unsafe {
+
+        /**
+         * Gets an Object from the config.
+         *
+         * <p>This method is nested under {@link Unsafe} because the keys
+         * and return types may change between versions without warning.</p>
+         *
+         * @param key the key, as defined as a parameter name in
+         *            the "ConfigKeys" class.
+         * @return the corresponding object, if one is present
+         * @throws IllegalArgumentException if the key isn't known
+         */
+        @Nonnull
+        Object getObject(String key);
+    }
+
 }

api/src/main/java/me/lucko/luckperms/api/LuckPermsApi.java

@@ -328,4 +328,31 @@ public interface LuckPermsApi {
     @Nonnull
     ContextSet getContextForPlayer(@Nonnull Object player);
 
+    /**
+     * Gets a Contexts instance for the player using the platforms {@link ContextCalculator}s.
+     *
+     * @param player the player to calculate for. Must be the player instance for the platform.
+     * @return a set of contexts.
+     * @since 3.3
+     */
+    @Nonnull
+    Contexts getContextsForPlayer(@Nonnull Object player);
+
+    /**
+     * Gets the unique players which have connected to the server since it started.
+     *
+     * @return the unique connections
+     * @since 3.3
+     */
+    @Nonnull
+    Set<UUID> getUniqueConnections();
+
+    /**
+     * Gets the time when the plugin first started in milliseconds.
+     *
+     * @return the enable time
+     * @since 3.3
+     */
+    long getStartTime();
+
 }

api/src/main/java/me/lucko/luckperms/api/PermissionHolder.java

@@ -25,10 +25,15 @@
 
 package me.lucko.luckperms.api;
 
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimap;
+
 import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.context.ImmutableContextSet;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
@@ -67,6 +72,47 @@ public interface PermissionHolder {
     @Nonnull
     String getFriendlyName();
 
+    /**
+     * Gets the backing multimap containing every permission this holder has.
+     *
+     * <p>This method <b>does not</b> resolve inheritance rules, and returns a
+     * view of what's 'in the file'.</p>
+     *
+     * @return the holders own permissions
+     * @since 3.3
+     */
+    @Nonnull
+    ImmutableSetMultimap<ImmutableContextSet, Node> getNodes();
+
+    /**
+     * Gets the backing multimap containing every transient permission this holder has.
+     *
+     * <p>This method <b>does not</b> resolve inheritance rules.</p>
+     *
+     * <p>Transient permissions only exist for the duration of the session.</p>
+     *
+     * @return the holders own permissions
+     * @since 3.3
+     */
+    @Nonnull
+    ImmutableSetMultimap<ImmutableContextSet, Node> getTransientNodes();
+
+    /**
+     * Gets a flattened/squashed view of the holders permissions.
+     *
+     * <p>This list is constructed using the {@link Multimap#values()} method
+     * of both the transient and enduring backing multimaps.</p>
+     *
+     * <p>This means that it <b>may contain</b> duplicate entries.</p>
+     *
+     * <p>Use {@link #getPermissions()} for a view without duplicates.</p>
+     *
+     * @return a list of the holders own nodes.
+     * @since 3.3
+     */
+    @Nonnull
+    List<Node> getOwnNodes();
+
     /**
      * Gets a sorted set of all held permissions.
      *
@@ -116,6 +162,38 @@ public interface PermissionHolder {
     @Nonnull
     Set<Node> getTemporaryPermissionNodes();
 
+    /**
+     * Recursively resolves this holders permissions.
+     *
+     * <p>The returned list will contain every inherited
+     * node the holder has, in the order that they were inherited in.</p>
+     *
+     * <p>This means the list will contain duplicates.</p>
+     *
+     * @param contexts the contexts for the lookup
+     * @return a list of nodes
+     * @since 3.3
+     */
+    @Nonnull
+    List<LocalizedNode> resolveInheritances(Contexts contexts);
+
+    /**
+     * Recursively resolves this holders permissions.
+     *
+     * <p>The returned list will contain every inherited
+     * node the holder has, in the order that they were inherited in.</p>
+     *
+     * <p>This means the list will contain duplicates.</p>
+     *
+     * <p>Unlike {@link #resolveInheritances(Contexts)}, this method does not
+     * filter by context, at all.</p>
+     *
+     * @return a list of nodes
+     * @since 3.3
+     */
+    @Nonnull
+    List<LocalizedNode> resolveInheritances();
+
     /**
      * Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context
      *
@@ -132,6 +210,20 @@ public interface PermissionHolder {
     @Nonnull
     SortedSet<LocalizedNode> getAllNodes(@Nonnull Contexts contexts);
 
+    /**
+     * Gets a mutable sorted set of the nodes that this object has and inherits.
+     *
+     * <p>Unlike {@link #getAllNodes(Contexts)}, this method does not filter by context, at all.</p>
+     *
+     * <p>Nodes are sorted into priority order.</p>
+     *
+     * @return a mutable sorted set of permissions
+     * @throws NullPointerException if the context is null
+     * @since 3.3
+     */
+    @Nonnull
+    SortedSet<LocalizedNode> getAllNodes();
+
     /**
      * Gets a mutable set of the nodes that this object has and inherits, filtered by context.
      *

api/src/main/java/me/lucko/luckperms/api/User.java

@@ -129,12 +129,13 @@ public interface User extends PermissionHolder {
     Optional<UserData> getUserDataCache();
 
     /**
-     * Sets up the users data cache, if the don't have one setup already.
+     * Pre-calculates some values in the user's data cache.
+     *
+     * <p>Is it <b>not</b> necessary to call this method before
+     * using {@link #getCachedData()}.</p>
      *
      * @since 2.17
-     * @deprecated in version 3.2, as this cache is now always loaded.
      */
-    @Deprecated
     void setupDataCache();
 
     /**