net.luckperms.api.LuckPermsProvider Java Examples

private void setUpForPermissionSystemTest() {
    if (permissionsSystemType == LUCK_PERMS) {
        LuckPerms api = mock(LuckPerms.class);
        ReflectionTestUtils.setField(LuckPermsProvider.class, null, "instance", api);
    } else if (permissionsSystemType == PERMISSIONS_EX) {
        throw new AssumptionViolatedException(
            "PermissionsEx instance cannot be mocked because of missing dependencies -- skipping");
    } else if (permissionsSystemType == Z_PERMISSIONS) {
        ZPermissionsService zPermissionsService = mock(ZPermissionsService.class);
        given(servicesManager.load(ZPermissionsService.class)).willReturn(zPermissionsService);
    } else if (permissionsSystemType == VAULT) {
        setUpForVault();
    } else {
        throw new IllegalStateException("Unhandled permission systems type: " + permissionsSystemType);
    }
}
 

/**
 * LuckPermsをロードする
 * @param plugin LuckPermsのインスタンス
 * @return ロードされたLuckPermsBridge
 */
public static LuckPermsBridge load(Plugin plugin) {

    // LuckPermsが指定されたかどうかを確認
    if ( plugin == null ) return null;

    // ロードされているならLuckPermsBridgeのインスタンスを作成して返す
    return new LuckPermsBridge(LuckPermsProvider.get());
}
 

public LuckPermsHandler() throws PermissionHandlerException {
    try {
        luckPerms = LuckPermsProvider.get();
    } catch (IllegalStateException e) {
        throw new PermissionHandlerException("Could not get api of LuckPerms", e);
    }
}
 

public HookLuckPerms(NametagHandler handler) {
    this.handler = handler;
    LuckPerms api = LuckPermsProvider.get();
    EventBus eventBus = api.getEventBus();
    eventBus.subscribe(UserDataRecalculateEvent.class, this::onUserDataRecalculateEvent);
}
 

/**
 * Creates a {@link WeightNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forWeight();
}
 

/**
 * Gets a {@link NodeBuilder} for the given node {@link #getKey() key}.
 *
 * @param key the key
 * @return the node builder
 */
static @NonNull NodeBuilder<?, ?> builder(@NonNull String key) {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forKey(key);
}
 

/**
 * Creates a {@link PermissionNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forPermission();
}
 

/**
 * Creates a {@link SuffixNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forSuffix();
}
 

/**
 * Creates a {@link MetaNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forMeta();
}
 

/**
 * Creates a {@link PrefixNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forPrefix();
}
 

/**
 * Creates a {@link RegexPermissionNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forRegexPermission();
}
 

/**
 * Creates a {@link DisplayNameNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forDisplayName();
}
 

/**
 * Creates a {@link InheritanceNode} builder.
 *
 * @return the builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getNodeBuilderRegistry().forInheritance();
}
 

/**
 * Gets a {@link NodeMatcher} which matches nodes which are
 * {@link Node#equals(Node, NodeEqualityPredicate) equal to} the given {@code other} node
 * according to the {@link NodeEqualityPredicate}.
 *
 * @param other the other node to test against
 * @param equalityPredicate the equality predicate
 * @param <T> the node type
 * @return the matcher
 */
static <T extends Node> @NonNull NodeMatcher<T> equals(@NonNull T other, @NonNull NodeEqualityPredicate equalityPredicate) {
    return LuckPermsProvider.get().getNodeMatcherFactory().equals(other, equalityPredicate);
}
 

/**
 * Gets a {@link NodeMatcher} which matches nodes with a {@link Node#getKey() key} starting
 * with the given string.
 *
 * @param startingWith the string to match
 * @return the matcher
 */
static @NonNull NodeMatcher<Node> keyStartsWith(@NonNull String startingWith) {
    return LuckPermsProvider.get().getNodeMatcherFactory().keyStartsWith(startingWith);
}
 

/**
 * Gets a {@link NodeMatcher} which matches nodes with the same {@link Node#getKey() key}.
 *
 * <p>The {@link String#equalsIgnoreCase(String)} method is used to test key equality.</p>
 *
 * @param node the node to use for the key
 * @param <T> the node type
 * @return the matcher
 */
static <T extends Node> @NonNull NodeMatcher<T> key(@NonNull T node) {
    return LuckPermsProvider.get().getNodeMatcherFactory().key(node);
}
 

/**
 * Gets a {@link Action.Builder}
 *
 * @return a new builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getActionLogger().actionBuilder();
}
 

/**
 * Creates a new empty MutableContextSet.
 *
 * @return a new MutableContextSet
 */
static @NonNull MutableContextSet create() {
    return LuckPermsProvider.get().getContextManager().getContextSetFactory().mutable();
}
 

/**
 * Creates an {@link ImmutableContextSet} from a context pair.
 *
 * @param key   the key
 * @param value the value
 * @return a new ImmutableContextSet containing one context pair
 * @throws NullPointerException if key or value is null
 */
static @NonNull ImmutableContextSet of(@NonNull String key, @NonNull String value) {
    return LuckPermsProvider.get().getContextManager().getContextSetFactory().immutableOf(key, value);
}
 

/**
 * Returns an empty {@link ImmutableContextSet}.
 *
 * @return an empty ImmutableContextSet
 */
static @NonNull ImmutableContextSet empty() {
    return LuckPermsProvider.get().getContextManager().getContextSetFactory().immutableEmpty();
}
 

/**
 * Creates an {@link ImmutableContextSet.Builder}.
 *
 * @return a new ImmutableContextSet builder
 */
static @NonNull Builder builder() {
    return LuckPermsProvider.get().getContextManager().getContextSetFactory().immutableBuilder();
}
 

/**
 * Gets the default {@link QueryMode#CONTEXTUAL contextual}
 * query options.
 *
 * <p>This instance has the default set of flags, and an empty set
 * of contexts.</p>
 *
 * @return the default contextual query options
 */
static @NonNull QueryOptions defaultContextualOptions() {
    return LuckPermsProvider.get().getQueryOptionsRegistry().defaultContextualOptions();
}
 

/**
 * Gets the default {@link QueryMode#NON_CONTEXTUAL non contextual}
 * query options.
 *
 * <p>This instance has the default set of flags.</p>
 *
 * @return the default non contextual query options
 */
static @NonNull QueryOptions nonContextual() {
    return LuckPermsProvider.get().getQueryOptionsRegistry().defaultNonContextualOptions();
}
 

/**
 * Creates a new {@link Builder} for the given {@link QueryMode}.
 *
 * @param mode the query mode
 * @return a new builder
 */
static @NonNull Builder builder(@NonNull QueryMode mode) {
    return LuckPermsProvider.get().getContextManager().queryOptionsBuilder(mode);
}