cn.nukkit.permission.Permissible Java Examples

public static void broadcastCommandMessage(CommandSender source, String message, boolean sendToSource) {
    Set<Permissible> users = source.getServer().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);

    TranslationContainer result = new TranslationContainer("chat.type.admin", new String[]{source.getName(), message});

    TranslationContainer colored = new TranslationContainer(TextFormat.GRAY + "" + TextFormat.ITALIC + "%chat.type.admin", new String[]{source.getName(), message});

    if (sendToSource && !(source instanceof ConsoleCommandSender)) {
        source.sendMessage(message);
    }

    for (Permissible user : users) {
        if (user instanceof CommandSender) {
            if (user instanceof ConsoleCommandSender) {
                ((ConsoleCommandSender) user).sendMessage(result);
            } else if (!user.equals(source)) {
                ((CommandSender) user).sendMessage(colored);
            }
        }
    }
}
 

@Override
public Set<Permissible> get(Object key) {
    if (key == null || !(key instanceof String)) {
        return null;
    }

    String permission = ((String) key);

    LPSubscriptionValueSet result = (LPSubscriptionValueSet) super.get(key);
    if (result == null) {
        // calculate a new map - always!
        result = new LPSubscriptionValueSet(permission);
        super.put(permission, result);
    }

    return result;
}
 

public static void broadcastCommandMessage(CommandSender source, String message, boolean sendToSource) {
    Set<Permissible> users = source.getServer().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);

    TranslationContainer result = new TranslationContainer("chat.type.admin", source.getName(), message);

    TranslationContainer colored = new TranslationContainer(TextFormat.GRAY + "" + TextFormat.ITALIC + "%chat.type.admin", source.getName(), message);

    if (sendToSource && !(source instanceof ConsoleCommandSender)) {
        source.sendMessage(message);
    }

    for (Permissible user : users) {
        if (user instanceof CommandSender) {
            if (user instanceof ConsoleCommandSender) {
                ((ConsoleCommandSender) user).sendMessage(result);
            } else if (!user.equals(source)) {
                ((CommandSender) user).sendMessage(colored);
            }
        }
    }
}
 

public PlayerChatEvent(Player player, String message, String format, Set<CommandSender> recipients) {
    this.player = player;
    this.message = message;

    this.format = format;

    if (recipients == null) {
        for (Permissible permissible : Server.getInstance().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_USERS)) {
            if (permissible instanceof CommandSender) {
                this.recipients.add((CommandSender) permissible);
            }
        }

    } else {
        this.recipients = recipients;
    }
}
 

public int broadcast(TextContainer message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

public int broadcast(String message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

@Override
public boolean contains(Object key) {
    // try the backing map
    if (this.backing.contains(key)) {
        return true;
    }

    // then try the permissible
    if (key instanceof Permissible) {
        Permissible p = (Permissible) key;
        return p.hasPermission(this.permission);
    }

    // no result
    return false;
}
 

private LuckPermsSubscriptionMap inject() throws Exception {
    Objects.requireNonNull(PERM_SUBS_FIELD, "PERM_SUBS_FIELD");
    PluginManager pluginManager = this.plugin.getBootstrap().getServer().getPluginManager();

    Object map = PERM_SUBS_FIELD.get(pluginManager);
    if (map instanceof LuckPermsSubscriptionMap) {
        if (((LuckPermsSubscriptionMap) map).plugin == this.plugin) {
            return null;
        }

        map = ((LuckPermsSubscriptionMap) map).detach();
    }

    //noinspection unchecked
    Map<String, Set<Permissible>> castedMap = (Map<String, Set<Permissible>>) map;

    // make a new subscription map & inject it
    LuckPermsSubscriptionMap newMap = new LuckPermsSubscriptionMap(this.plugin, castedMap);
    PERM_SUBS_FIELD.set(pluginManager, newMap);
    return newMap;
}
 

public static void broadcastCommandMessage(CommandSender source, String message, boolean sendToSource) {
    Set<Permissible> users = source.getServer().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);

    TranslationContainer result = new TranslationContainer("chat.type.admin", new String[]{source.getName(), message});

    TranslationContainer colored = new TranslationContainer(TextFormat.GRAY + "" + TextFormat.ITALIC + "%chat.type.admin", new String[]{source.getName(), message});

    if (sendToSource && !(source instanceof ConsoleCommandSender)) {
        source.sendMessage(message);
    }

    for (Permissible user : users) {
        if (user instanceof CommandSender) {
            if (user instanceof ConsoleCommandSender) {
                ((ConsoleCommandSender) user).sendMessage(result);
            } else if (!user.equals(source)) {
                ((CommandSender) user).sendMessage(colored);
            }
        }
    }
}
 

public PlayerChatEvent(Player player, String message, String format, Set<CommandSender> recipients) {
    this.player = player;
    this.message = message;

    this.format = format;

    if (recipients == null) {
        for (Permissible permissible : Server.getInstance().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_USERS)) {
            if (permissible instanceof CommandSender) {
                this.recipients.add((CommandSender) permissible);
            }
        }

    } else {
        this.recipients = recipients;
    }
}
 

public int broadcastImportantMessage(String message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendImportantMessage(message);
    }

    return recipients.size();
}
 

public int broadcastTitle(String message, String permissions) {
    Set<Player> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof Player && permissible.hasPermission(permission)) {
                recipients.add((Player) permissible);
            }
        }
    }

    for (Player recipient : recipients) {
        recipient.sendTitle(message);
    }

    return recipients.size();
}
 

public PlayerChatEvent(Player player, String message, String format, Set<CommandSender> recipients) {
    this.player = player;
    this.message = message;

    this.format = format;

    if (recipients == null) {
        for (Permissible permissible : Server.getInstance().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_USERS)) {
            if (permissible instanceof CommandSender) {
                this.recipients.add((CommandSender) permissible);
            }
        }

    } else {
        this.recipients = recipients;
    }
}
 

public int broadcast(TextContainer message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

public int broadcast(String message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

public int broadcast(String message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

public int broadcast(TextContainer message, String permissions) {
    Set<CommandSender> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
                recipients.add((CommandSender) permissible);
            }
        }
    }

    for (CommandSender recipient : recipients) {
        recipient.sendMessage(message);
    }

    return recipients.size();
}
 

public int broadcastPopup(String message, String permissions) {
    Set<Player> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof Player && permissible.hasPermission(permission)) {
                recipients.add((Player) permissible);
            }
        }
    }

    for (Player recipient : recipients) {
        recipient.sendPopup(message);
    }

    return recipients.size();
}
 

public int broadcastTip(String message, String permissions) {
    Set<Player> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof Player && permissible.hasPermission(permission)) {
                recipients.add((Player) permissible);
            }
        }
    }

    for (Player recipient : recipients) {
        recipient.sendTip(message);
    }

    return recipients.size();
}
 

public int broadcastSubtitle(String message, String permissions) {
    Set<Player> recipients = new HashSet<>();

    for (String permission : permissions.split(";")) {
        for (Permissible permissible : this.pluginManager.getPermissionSubscriptions(permission)) {
            if (permissible instanceof Player && permissible.hasPermission(permission)) {
                recipients.add((Player) permissible);
            }
        }
    }

    for (Player recipient : recipients) {
        recipient.setSubtitle(message);
    }

    return recipients.size();
}
 

public void unsubscribeFromPermission(String permission, Permissible permissible) {
    if (this.permSubs.containsKey(permission)) {
        this.permSubs.get(permission).remove(permissible);
        if (this.permSubs.get(permission).size() == 0) {
            this.permSubs.remove(permission);
        }
    }
}
 

public Set<Permissible> getPermissionSubscriptions(String permission) {
    if (this.permSubs.containsKey(permission)) {
        Set<Permissible> subs = new HashSet<>();
        for (Permissible p : this.permSubs.get(permission).values()) {
            subs.add(p);
        }
        return subs;
    }

    return new HashSet<>();
}
 

@Override
public boolean add(Permissible permissible) {
    // don't allow players to be put into this map
    if (permissible instanceof Player) {
        return true;
    }

    return this.backing.add(permissible);
}
 

public void subscribeToDefaultPerms(boolean op, Permissible permissible) {
    if (op) {
        this.defSubsOp.put(permissible, permissible);
    } else {
        this.defSubs.put(permissible, permissible);
    }
}
 

private Set<Permissible> getContentView() {
    // gather players (LPPermissibles)
    Set<Permissible> players = LuckPermsSubscriptionMap.this.plugin.getBootstrap().getServer().getOnlinePlayers().values().stream()
            .filter(player -> player.hasPermission(this.permission) || player.isPermissionSet(this.permission))
            .collect(Collectors.toSet());

    ImmutableSet<Permissible> backing;
    synchronized (this.backing) {
        backing = ImmutableSet.copyOf(this.backing);
    }

    return Sets.union(players, backing);
}
 

private LPSubscriptionValueSet(String permission, Set<Permissible> content) {
    this.permission = permission;
    this.backing = Collections.synchronizedSet(Collections.newSetFromMap(new WeakHashMap<>()));
    
    if (content != null) {
        this.backing.addAll(content);
    }

    // remove all players from the map
    this.backing.removeIf(p -> p instanceof Player);
}
 

public void unsubscribeFromDefaultPerms(boolean op, Permissible permissible) {
    if (op) {
        this.defSubsOp.remove(permissible);
    } else {
        this.defSubs.remove(permissible);
    }
}
 

/**
 * Converts this map back to a standard HashMap
 *
 * @return a standard representation of this map
 */
public Map<String, Set<Permissible>> detach() {
    Map<String, Set<Permissible>> map = new HashMap<>();
    for (Map.Entry<String, Set<Permissible>> ent : entrySet()) {
        Set<Permissible> backing = ((LPSubscriptionValueSet) ent.getValue()).backing;
        Set<Permissible> copy = Collections.newSetFromMap(new WeakHashMap<>(backing.size()));
        copy.addAll(backing);
        map.put(ent.getKey(), copy);
    }
    return map;
}
 

@Override
public Set<Permissible> put(String key, Set<Permissible> value) {
    if (value == null) {
        throw new NullPointerException("Map value cannot be null");
    }

    // ensure values are LP subscription maps
    if (!(value instanceof LPSubscriptionValueSet)) {
        value = new LPSubscriptionValueSet(key, value);
    }
    return super.put(key, value);
}
 

public static void broadcastCommandMessage(CommandSender source, TextContainer message, boolean sendToSource) {
    TextContainer m = message.clone();
    String resultStr = "[" + source.getName() + ": " + (!m.getText().equals(source.getServer().getLanguage().get(m.getText())) ? "%" : "") + m.getText() + "]";

    Set<Permissible> users = source.getServer().getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);

    String coloredStr = TextFormat.GRAY + "" + TextFormat.ITALIC + resultStr;

    m.setText(resultStr);
    TextContainer result = m.clone();
    m.setText(coloredStr);
    TextContainer colored = m.clone();

    if (sendToSource && !(source instanceof ConsoleCommandSender)) {
        source.sendMessage(message);
    }

    for (Permissible user : users) {
        if (user instanceof CommandSender) {
            if (user instanceof ConsoleCommandSender) {
                ((ConsoleCommandSender) user).sendMessage(result);
            } else if (!user.equals(source)) {
                ((CommandSender) user).sendMessage(colored);
            }
        }
    }
}