me.lucko.luckperms.api

Interface PermissionHolder

All Known Subinterfaces:

Group, User

public interface PermissionHolder

Generic superinterface for an object which holds permissions.

Method Summary

Modifier and Type	Method and Description
void	auditTemporaryPermissions() Removes any temporary permissions that have expired.
void	clearMatching(@NonNull Predicate<Node> test) Clears any nodes from the holder which pass the predicate.
void	clearMatchingTransient(@NonNull Predicate<Node> test) Clears any transient nodes from the holder which pass the predicate.
void	clearMeta() Clears all meta held by the permission holder.
void	clearMeta(@NonNull ContextSet contextSet) Clears all meta held by the permission holder in a specific context.
void	clearNodes() Clears all nodes held by the permission holder.
void	clearNodes(@NonNull ContextSet contextSet) Clears all nodes held by the permission holder in a specific context.
void	clearParents() Clears all parent groups.
void	clearParents(@NonNull ContextSet contextSet) Clears all parent groups in a specific context.
void	clearTransientNodes() Clears all transient nodes the permission holder has.
@NonNull Map<String,Boolean>	exportNodes(@NonNull Contexts contexts, boolean convertToLowercase) Converts the output of getAllNodesFiltered(Contexts) into string and boolean form, and expands shorthand permissions.
@NonNull SortedSet<LocalizedNode>	getAllNodes() Gets a mutable sorted set of the nodes that this object has and inherits.
@NonNull SortedSet<LocalizedNode>	getAllNodes(@NonNull Contexts contexts) Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context
@NonNull Set<LocalizedNode>	getAllNodesFiltered(@NonNull Contexts contexts) Gets a mutable set of the nodes that this object has and inherits, filtered by context.
@NonNull CachedData	getCachedData() Gets the holders CachedData cache.
@NonNull Set<? extends Node>	getEnduringPermissions() Similar to getPermissions(), except only including permissions from the enduring node map.
@NonNull String	getFriendlyName() Gets a friendly name for this holder, to be displayed in command output, etc.
@NonNull ImmutableSetMultimap<ImmutableContextSet,Node>	getNodes() Gets the backing multimap containing every permission this holder has.
@NonNull String	getObjectName() Gets the objects generic name.
@NonNull List<Node>	getOwnNodes() Gets a flattened/squashed view of the holders permissions.
@NonNull Set<Node>	getPermanentPermissionNodes() A filtered view of this holders nodes, only including permanent entries.
@NonNull SortedSet<? extends Node>	getPermissions() Gets a sorted set of all held permissions.
@NonNull Set<Node>	getTemporaryPermissionNodes() A filtered view of this holders nodes, only including temporary entries.
@NonNull ImmutableSetMultimap<ImmutableContextSet,Node>	getTransientNodes() Gets the backing multimap containing every transient permission this holder has.
@NonNull Set<? extends Node>	getTransientPermissions() Similar to getPermissions(), except only including permissions from the enduring node map.
@NonNull Tristate	hasPermission(@NonNull Node node) Checks to see if the object has a certain permission.
@NonNull Tristate	hasPermission(@NonNull Node node, @NonNull NodeEqualityPredicate equalityPredicate) Checks to see if the object has a certain permission.
@NonNull Tristate	hasTransientPermission(@NonNull Node node) Checks to see if the object has a certain permission.
@NonNull Tristate	hasTransientPermission(@NonNull Node node, @NonNull NodeEqualityPredicate equalityPredicate) Checks to see if the object has a certain permission.
boolean	inheritsGroup(@NonNull Group group) Check to see if this holder inherits another group in the global context.
boolean	inheritsGroup(@NonNull Group group, @NonNull ContextSet contextSet) Check to see if this holder inherits another group.
@NonNull Tristate	inheritsPermission(@NonNull Node node) Checks to see if the object inherits a certain permission.
@NonNull Tristate	inheritsPermission(@NonNull Node node, @NonNull NodeEqualityPredicate equalityPredicate) Checks to see if the object inherits a certain permission.
@NonNull CompletableFuture<Void>	refreshCachedData() Refreshes and applies any changes to the cached holder data.
@NonNull List<LocalizedNode>	resolveInheritances() Recursively resolves this holders permissions.
@NonNull List<LocalizedNode>	resolveInheritances(@NonNull Contexts contexts) Recursively resolves this holders permissions.
@NonNull DataMutateResult	setPermission(@NonNull Node node) Sets a permission node for the permission holder.
@NonNull TemporaryDataMutateResult	setPermission(@NonNull Node node, @NonNull TemporaryMergeBehaviour temporaryMergeBehaviour) Sets a permission node for the permission holder.
default @NonNull DataMutateResult	setPermissionUnchecked(@NonNull Node node) Deprecated. now forwards to setPermission(Node).
@NonNull DataMutateResult	setTransientPermission(@NonNull Node node) Sets a transient permission for the permission holder.
@NonNull TemporaryDataMutateResult	setTransientPermission(@NonNull Node node, @NonNull TemporaryMergeBehaviour temporaryMergeBehaviour) Sets a transient permission for the permission holder.
default @NonNull DataMutateResult	setTransientPermissionUnchecked(@NonNull Node node) Deprecated. now forwards to setTransientPermission(Node)
@NonNull DataMutateResult	unsetPermission(@NonNull Node node) Unsets a permission for the permission holder.
default @NonNull DataMutateResult	unsetPermissionUnchecked(@NonNull Node node) Deprecated. now forwards to unsetPermission(Node)
@NonNull DataMutateResult	unsetTransientPermission(@NonNull Node node) Unsets a transient permission for the permission holder.
default @NonNull DataMutateResult	unsetTransientPermissionUnchecked(@NonNull Node node) Deprecated. now forwards to unsetTransientPermission(Node)

Method Detail

getObjectName

@NonNull String getObjectName()

Gets the objects generic name.

The result of this method is guaranteed to be a unique identifier for distinct instances of the same type of object.

For Users, this method returns a string representation of the users unique id.

For Groups, this method returns the group name.

The User.getUuid(), User.getName() and Group.getName() methods define a "tighter" specification for obtaining object identifiers.

Returns:

the identifier for this object. Either a uuid string or name.

getFriendlyName

@NonNull String getFriendlyName()

Gets a friendly name for this holder, to be displayed in command output, etc.

This will always return a value, eventually falling back to getObjectName() if no other "friendlier" identifiers are present.

For Users, this method will attempt to return the username, before falling back to getObjectName().

For Groups, this method will attempt to return the groups display name, before falling back to getObjectName().

Returns:

a friendly identifier for this holder

Since:

3.2

getCachedData

@NonNull CachedData getCachedData()

Gets the holders CachedData cache.

Returns:

the holders cached data.

Since:

3.2

refreshCachedData

@NonNull CompletableFuture<Void> refreshCachedData()

Refreshes and applies any changes to the cached holder data.

Calling this method is unnecessary in most cases. Cache updates are handled behind the scenes by the implementation.

Returns:

the task future

Since:

4.0

getNodes

@NonNull ImmutableSetMultimap<ImmutableContextSet,Node> getNodes()

Gets the backing multimap containing every permission this holder has.

This method does not resolve inheritance rules, and returns a view of what's 'in the file'.

Returns:

the holders own permissions

Since:

3.3

getTransientNodes

@NonNull ImmutableSetMultimap<ImmutableContextSet,Node> getTransientNodes()

Gets the backing multimap containing every transient permission this holder has.

This method does not resolve inheritance rules.

Transient permissions only exist for the duration of the session.

Returns:

the holders own permissions

Since:

3.3

getOwnNodes

@NonNull List<Node> getOwnNodes()

Gets a flattened/squashed view of the holders permissions.

This list is constructed using the Multimap.values() method of both the transient and enduring backing multimaps.

This means that it may contain duplicate entries.

Use getPermissions() for a view without duplicates.

This method does not resolve inheritance rules.

Returns:

a list of the holders own nodes.

Since:

3.3

getPermissions

@NonNull SortedSet<? extends Node> getPermissions()

Gets a sorted set of all held permissions.

Effectively a sorted version of getOwnNodes(), without duplicates. Use the aforementioned method if you don't require either of these attributes.

This method does not resolve inheritance rules.

Although this method is named getPermissions, it will actually return all types of node.

Returns:

an immutable set of permissions in priority order

Since:

2.6

getEnduringPermissions

@NonNull Set<? extends Node> getEnduringPermissions()

Similar to getPermissions(), except only including permissions from the enduring node map. (See getNodes())

Unlike transient permissions, enduring permissions will be saved to storage, and exist after the session.

This method does not resolve inheritance rules.

Although this method is named getEnduringPermissions, it will actually return all types of node.

Returns:

a set of nodes

Since:

2.6

getTransientPermissions

@NonNull Set<? extends Node> getTransientPermissions()

Similar to getPermissions(), except only including permissions from the enduring node map. (See getTransientNodes())

Transient permissions only exist for the duration of the session.

This method does not resolve inheritance rules.

Although this method is named getTransientPermissions, it will actually return all types of node.

Returns:

a set of nodes

Since:

2.6

getPermanentPermissionNodes

@NonNull Set<Node> getPermanentPermissionNodes()

A filtered view of this holders nodes, only including permanent entries.

Data is sourced from getOwnNodes(), filtered, and then collected to a set.

This method does not resolve inheritance rules.

Although this method is named getPermanentPermissionNodes, it will actually return all types of node.

Returns:

a set of permanent nodes

Since:

2.6

getTemporaryPermissionNodes

@NonNull Set<Node> getTemporaryPermissionNodes()

A filtered view of this holders nodes, only including temporary entries.

Data is sourced from getOwnNodes(), filtered, and then collected to a set.

This method does not resolve inheritance rules.

Although this method is named getTemporaryPermissionNodes, it will actually return all types of node.

Returns:

a set of temporary nodes

Since:

2.6

resolveInheritances

@NonNull List<LocalizedNode> resolveInheritances(@NonNull Contexts contexts)

Recursively resolves this holders permissions.

The returned list will contain every inherited node the holder has, in the order that they were inherited in.

This means the list will contain duplicates.

Inheritance is performed according to the platforms rules, and the order will vary depending on the accumulation order. By default, the holders own nodes are first in the list, with the entries from the end of the inheritance tree appearing last.

Parameters:

contexts - the contexts for the lookup

Returns:

a list of nodes

Since:

3.3

resolveInheritances

@NonNull List<LocalizedNode> resolveInheritances()

Recursively resolves this holders permissions.

The returned list will contain every inherited node the holder has, in the order that they were inherited in.

This means the list will contain duplicates.

Unlike resolveInheritances(Contexts), this method does not filter by context, at all.

Inheritance is performed according to the platforms rules, and the order will vary depending on the accumulation order. By default, the holders own nodes are first in the list, with the entries from the end of the inheritance tree appearing last.

Returns:

a list of nodes

Since:

3.3

getAllNodes

@NonNull SortedSet<LocalizedNode> getAllNodes(@NonNull Contexts contexts)

Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context

Unlike getAllNodesFiltered(Contexts), this method will not filter individual nodes by context. The context is only used to determine which groups should apply.

Nodes are sorted into priority order. The order of inheritance is only important during the process of flattening inherited entries.

Parameters:

contexts - the context for the lookup

Returns:

an immutable sorted set of permissions

Throws:

NullPointerException - if the context is null

Since:

2.11

getAllNodes

@NonNull SortedSet<LocalizedNode> getAllNodes()

Gets a mutable sorted set of the nodes that this object has and inherits.

Unlike getAllNodes(Contexts), this method does not filter by context, at all.

Nodes are sorted into priority order. The order of inheritance is only important during the process of flattening inherited entries.

Returns:

an immutable sorted set of permissions

Throws:

NullPointerException - if the context is null

Since:

3.3

getAllNodesFiltered

@NonNull Set<LocalizedNode> getAllNodesFiltered(@NonNull Contexts contexts)

Gets a mutable set of the nodes that this object has and inherits, filtered by context.

Unlike getAllNodes(Contexts), this method WILL filter individual nodes, and only return ones that fully meet the context provided.

Parameters:

contexts - the context for the lookup

Returns:

a mutable set of permissions

Throws:

NullPointerException - if the context is null

Since:

2.11

exportNodes

@NonNull Map<String,Boolean> exportNodes(@NonNull Contexts contexts,
                                         boolean convertToLowercase)

Converts the output of getAllNodesFiltered(Contexts) into string and boolean form, and expands shorthand permissions.

Parameters:

contexts - the context for the lookup

convertToLowercase - if the keys should be made lowercase whilst being exported

Returns:

a mutable map of permissions

auditTemporaryPermissions

void auditTemporaryPermissions()

Removes any temporary permissions that have expired.

This method is called periodically by the platform, so it is only necessary to run if you want to guarentee that the current data is totally up-to-date.

hasPermission

@NonNull Tristate hasPermission(@NonNull Node node,
                                @NonNull NodeEqualityPredicate equalityPredicate)

Checks to see if the object has a certain permission.

Although this method is named hasPermission, it can be used for all node types.

Parameters:

node - the node to check for

equalityPredicate - how to determine if a node matches

Returns:

a Tristate for the holders permission status for the node

Throws:

NullPointerException - if the node is null

Since:

4.1

hasTransientPermission

@NonNull Tristate hasTransientPermission(@NonNull Node node,
                                         @NonNull NodeEqualityPredicate equalityPredicate)

Checks to see if the object has a certain permission.

Although this method is named hasTransientPermission, it can be used for all node types.

Parameters:

node - the node to check for

equalityPredicate - how to determine if a node matches

Returns:

a Tristate for the holders permission status for the node

Throws:

NullPointerException - if the node is null

Since:

4.1

inheritsPermission

@NonNull Tristate inheritsPermission(@NonNull Node node,
                                     @NonNull NodeEqualityPredicate equalityPredicate)

Checks to see if the object inherits a certain permission.

Although this method is named inheritsPermission, it can be used for all node types.

Parameters:

node - the node to check for

equalityPredicate - how to determine if a node matches

Returns:

a Tristate for the holders inheritance status for the node

Throws:

NullPointerException - if the node is null

Since:

4.1

hasPermission

@NonNull Tristate hasPermission(@NonNull Node node)

Checks to see if the object has a certain permission.

Although this method is named hasPermission, it can be used for all node types.

Parameters:

node - the node to check for

Returns:

a Tristate for the holders permission status for the node

Throws:

NullPointerException - if the node is null

Since:

2.6

hasTransientPermission

@NonNull Tristate hasTransientPermission(@NonNull Node node)

Checks to see if the object has a certain permission.

Although this method is named hasTransientPermission, it can be used for all node types.

Parameters:

node - the node to check for

Returns:

a Tristate for the holders permission status for the node

Throws:

NullPointerException - if the node is null

Since:

2.6

inheritsPermission

@NonNull Tristate inheritsPermission(@NonNull Node node)

Checks to see if the object inherits a certain permission.

Although this method is named inheritsPermission, it can be used for all node types.

Parameters:

node - the node to check for

Returns:

a Tristate for the holders inheritance status for the node

Throws:

NullPointerException - if the node is null

Since:

2.6

inheritsGroup

boolean inheritsGroup(@NonNull Group group)

Check to see if this holder inherits another group in the global context.

"Global context" simply means an empty context set.

This method only checks for direct inheritance - one hop up the inheritance tree.

Parameters:

group - The group to check membership of

Returns:

true if the group inherits the other group

Throws:

NullPointerException - if the group is null

IllegalStateException - if the group instance was not obtained from LuckPerms.

Since:

4.0

inheritsGroup

boolean inheritsGroup(@NonNull Group group,
                      @NonNull ContextSet contextSet)

Check to see if this holder inherits another group.

This method only checks for direct inheritance - one hop up the inheritance tree.

Parameters:

group - The group to check membership of

contextSet - the context set to filter by

Returns:

true if the group inherits the other group

Throws:

NullPointerException - if the group is null

IllegalStateException - if the group instance was not obtained from LuckPerms.

Since:

4.0

setPermission

@NonNull DataMutateResult setPermission(@NonNull Node node)

Sets a permission node for the permission holder.

Although this method is named setPermission, it can be used for all node types.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

node - The node to be set

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.0

setPermission

@NonNull TemporaryDataMutateResult setPermission(@NonNull Node node,
                                                 @NonNull TemporaryMergeBehaviour temporaryMergeBehaviour)

Sets a permission node for the permission holder.

Although this method is named setPermission, it can be used for all node types.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

node - The node to be set

temporaryMergeBehaviour - The behaviour used to merge temporary permission entries

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.3

setTransientPermission

@NonNull DataMutateResult setTransientPermission(@NonNull Node node)

Sets a transient permission for the permission holder.

A transient node is a permission that does not persist. Whenever a user logs out of the server, or the server restarts, this permission will disappear. It is never saved to the datastore, and therefore will not apply on other servers.

This is useful if you want to temporarily set a permission for a user while they're online, but don't want it to persist, and have to worry about removing it when they log out.

For unsetting a transient permission, see unsetTransientPermission(Node).

Although this method is named setTransientPermission, it can be used for all node types.

Parameters:

node - The node to be set

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.0

setTransientPermission

@NonNull TemporaryDataMutateResult setTransientPermission(@NonNull Node node,
                                                          @NonNull TemporaryMergeBehaviour temporaryMergeBehaviour)

Sets a transient permission for the permission holder.

A transient node is a permission that does not persist. Whenever a user logs out of the server, or the server restarts, this permission will disappear. It is never saved to the datastore, and therefore will not apply on other servers.

This is useful if you want to temporarily set a permission for a user while they're online, but don't want it to persist, and have to worry about removing it when they log out.

For unsetting a transient permission, see unsetTransientPermission(Node).

Although this method is named setTransientPermission, it can be used for all node types.

Parameters:

node - The node to be se

temporaryMergeBehaviour - The behaviour used to merge temporary permission entries

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.3

unsetPermission

@NonNull DataMutateResult unsetPermission(@NonNull Node node)

Unsets a permission for the permission holder.

Although this method is named unsetPermission, it can be used for all node types.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

node - The node to be unset

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.0

unsetTransientPermission

@NonNull DataMutateResult unsetTransientPermission(@NonNull Node node)

Unsets a transient permission for the permission holder.

Although this method is named unsetTransientPermission, it can be used for all node types.

Parameters:

node - The node to be unset

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

4.0

clearMatching

void clearMatching(@NonNull Predicate<Node> test)

Clears any nodes from the holder which pass the predicate.

This method only targets enduring data.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

test - the predicate to test for nodes which should be removed

Since:

3.2

clearMatchingTransient

void clearMatchingTransient(@NonNull Predicate<Node> test)

Clears any transient nodes from the holder which pass the predicate.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

test - the predicate to test for nodes which should be removed

Since:

3.2

clearNodes

void clearNodes()

Clears all nodes held by the permission holder.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Since:

2.17

clearNodes

void clearNodes(@NonNull ContextSet contextSet)

Clears all nodes held by the permission holder in a specific context.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

contextSet - the contexts to filter by

Since:

3.2

clearParents

void clearParents()

Clears all parent groups.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Since:

2.17

clearParents

void clearParents(@NonNull ContextSet contextSet)

Clears all parent groups in a specific context.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

contextSet - the contexts to filter by

Since:

3.2

clearMeta

void clearMeta()

Clears all meta held by the permission holder.

Meta nodes in this case, are any nodes which have a MetaType, PrefixType or SuffixType type.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Since:

2.17

clearMeta

void clearMeta(@NonNull ContextSet contextSet)

Clears all meta held by the permission holder in a specific context.

Meta nodes in this case, are any nodes which have a MetaType, PrefixType or SuffixType type.

The effect of this mutate operation will not persist in storage unless changes are explicitly saved. If changes are not saved, the effect will only be observed until the next time the holders permission data is (re)loaded. Changes to Users should be saved using UserManager.saveUser(User), and changes to Groups should be saved using GroupManager.saveGroup(Group).

Before making changes to a user or group, it may be a good idea to load a fresh copy of the backing data from the storage if you haven't done so already, to avoid overwriting changes made already. This can be done via UserManager.loadUser(UUID) or GroupManager.loadGroup(String) respectively.

Parameters:

contextSet - the contexts to filter by

Since:

3.2

clearTransientNodes

void clearTransientNodes()

Clears all transient nodes the permission holder has.

setPermissionUnchecked

@Deprecated
default @NonNull DataMutateResult setPermissionUnchecked(@NonNull Node node)

Deprecated. now forwards to setPermission(Node).

Sets a permission for the permission holder.

Parameters:

node - The node to be set

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

3.1

setTransientPermissionUnchecked

@Deprecated
default @NonNull DataMutateResult setTransientPermissionUnchecked(@NonNull Node node)

Deprecated. now forwards to setTransientPermission(Node)

Sets a transient permission for the permission holder.

Parameters:

node - The node to be set

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

3.1

unsetPermissionUnchecked

@Deprecated
default @NonNull DataMutateResult unsetPermissionUnchecked(@NonNull Node node)

Deprecated. now forwards to unsetPermission(Node)

Unsets a permission for the permission holder.

Parameters:

node - The node to be unset

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

3.1

unsetTransientPermissionUnchecked

@Deprecated
default @NonNull DataMutateResult unsetTransientPermissionUnchecked(@NonNull Node node)

Deprecated. now forwards to unsetTransientPermission(Node)

Unsets a transient permission for the permission holder.

Parameters:

node - The node to be unset

Returns:

the result of the operation

Throws:

NullPointerException - if the node is null

Since:

3.1