worldofcraft/LuckPerms-DBA
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

misc cleanup

Browse Source
This commit is contained in:
Luck
2017-12-23 23:51:42 +00:00
Unverified
parent 862fe6e2e3
commit 6602b23f09
36 changed files with 281 additions and 4022 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiConfiguration.java
+3 -1
View File
@@ -29,6 +29,7 @@ import me.lucko.luckperms.api.LPConfiguration;
import me.lucko.luckperms.common.config.ConfigKey;
import me.lucko.luckperms.common.config.ConfigKeys;
import me.lucko.luckperms.common.config.LuckPermsConfiguration;
import me.lucko.luckperms.common.utils.ImmutableCollectors;
import java.util.Map;
@@ -78,7 +79,8 @@ public class ApiConfiguration implements LPConfiguration {
@Override
public Map<String, String> getSplitStorageOptions() {
return handle.get(ConfigKeys.SPLIT_STORAGE_OPTIONS);
return handle.get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream()
.collect(ImmutableCollectors.toMap(e -> e.getKey().name().toLowerCase(), Map.Entry::getValue));
}
@Override
common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentRule.java
+1 -1
View File
@@ -51,7 +51,7 @@ public class AssignmentRule {
this.hasTrueExpression = AssignmentExpression.compile(hasTrueExpression);
this.hasFalseExpression = AssignmentExpression.compile(hasFalseExpression);
this.lacksExpression = AssignmentExpression.compile(lacksExpression);
this.toGive = toGive.stream().map(s -> LegacyNodeFactory.fromLegacyString(s, true)).collect(ImmutableCollectors.toList());;
this.toGive = toGive.stream().map(s -> LegacyNodeFactory.fromLegacyString(s, true)).collect(ImmutableCollectors.toList());
this.toTake = toTake.stream().map(s -> LegacyNodeFactory.fromLegacyString(s, true)).collect(ImmutableCollectors.toList());
this.setPrimaryGroup = setPrimaryGroup;
}
common/src/main/java/me/lucko/luckperms/common/backup/Importer.java
+10 -6
View File
@@ -155,12 +155,16 @@ public class Importer implements Runnable {
int errors = (int) toExecute.stream().filter(v -> !v.getResult().asBoolean()).count();
if (errors == 0) {
notify.forEach(s -> Message.IMPORT_END_COMPLETE.send(s, seconds));
} else if (errors == 1) {
notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR_SIN.send(s, seconds, errors));
} else {
notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR.send(s, seconds, errors));
switch (errors) {
case 0:
notify.forEach(s -> Message.IMPORT_END_COMPLETE.send(s, seconds));
break;
case 1:
notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR_SIN.send(s, seconds, errors));
break;
default:
notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR.send(s, seconds, errors));
break;
}
AtomicInteger errIndex = new AtomicInteger(1);
common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdateBuilder.java
+1 -1
View File
@@ -50,7 +50,7 @@ public class BulkUpdateBuilder {
private Action action = null;
// a set of constraints which data must match to be acted upon
private Set<Constraint> constraints = new LinkedHashSet<>();
private final Set<Constraint> constraints = new LinkedHashSet<>();
public BulkUpdateBuilder action(Action action) {
this.action = action;
common/src/main/java/me/lucko/luckperms/common/commands/CommandManager.java
+1 -5
View File
@@ -245,12 +245,8 @@ public class CommandManager {
arguments.remove(0); // remove the main command arg.
if (!o.isPresent()) {
return Collections.emptyList();
}
// Pass the processing onto the main command
return o.get().tabComplete(plugin, sender, arguments);
return o.map(cmd -> cmd.tabComplete(plugin, sender, arguments)).orElseGet(Collections::emptyList);
}
private void sendCommandUsage(Sender sender, String label) {
common/src/main/java/me/lucko/luckperms/common/commands/CommandPermission.java
+1 -1
View File
@@ -174,7 +174,7 @@ public enum CommandPermission {
private final String node;
@Getter
private Type type;
private final Type type;
CommandPermission(String node, Type type) {
this.type = type;
common/src/main/java/me/lucko/luckperms/common/commands/abstraction/MainCommand.java
+1 -4
View File
@@ -149,11 +149,8 @@ public abstract class MainCommand<T, I> extends Command<Void, T> {
.filter(s -> s.getName().equalsIgnoreCase(args.get(1)))
.findFirst();
if (!o.isPresent()) {
return Collections.emptyList();
}
return o.map(cmd -> cmd.tabComplete(plugin, sender, args.subList(2, args.size()))).orElseGet(Collections::emptyList);
return o.get().tabComplete(plugin, sender, args.subList(2, args.size()));
}
protected abstract List<String> getTargets(LuckPermsPlugin plugin);
common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedMainCommand.java
+1 -4
View File
@@ -128,11 +128,8 @@ public class SharedMainCommand<T extends PermissionHolder> extends SubCommand<T>
.limit(1)
.findAny();
if (!o.isPresent()) {
return Collections.emptyList();
}
return o.map(cmd -> cmd.onTabComplete(plugin, sender, args.subList(1, args.size()))).orElseGet(Collections::emptyList);
return o.get().onTabComplete(plugin, sender, args.subList(1, args.size()));
}
@Override
common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogMainCommand.java
+1 -5
View File
@@ -112,10 +112,6 @@ public class LogMainCommand extends MainCommand<Log, Object> {
.limit(1)
.findAny();
if (!o.isPresent()) {
return Collections.emptyList();
}
return o.get().tabComplete(plugin, sender, args.subList(1, args.size()));
return o.map(cmd -> cmd.tabComplete(plugin, sender, args.subList(1, args.size()))).orElseGet(Collections::emptyList);
}
}
common/src/main/java/me/lucko/luckperms/common/config/ConfigKeys.java
+10 -8
View File
@@ -49,12 +49,14 @@ import me.lucko.luckperms.common.primarygroup.AllParentsByWeightHolder;
import me.lucko.luckperms.common.primarygroup.ParentsByWeightHolder;
import me.lucko.luckperms.common.primarygroup.PrimaryGroupHolder;
import me.lucko.luckperms.common.primarygroup.StoredHolder;
import me.lucko.luckperms.common.storage.SplitStorageType;
import me.lucko.luckperms.common.storage.StorageCredentials;
import me.lucko.luckperms.common.utils.ImmutableCollectors;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@@ -417,14 +419,14 @@ public class ConfigKeys {
/**
* The options for split storage
*/
public static final ConfigKey<Map<String, String>> SPLIT_STORAGE_OPTIONS = EnduringKey.wrap(AbstractKey.of(c -> {
return ImmutableMap.<String, String>builder()
.put("user", c.getString("split-storage.methods.user", "h2").toLowerCase())
.put("group", c.getString("split-storage.methods.group", "h2").toLowerCase())
.put("track", c.getString("split-storage.methods.track", "h2").toLowerCase())
.put("uuid", c.getString("split-storage.methods.uuid", "h2").toLowerCase())
.put("log", c.getString("split-storage.methods.log", "h2").toLowerCase())
.build();
public static final ConfigKey<Map<SplitStorageType, String>> SPLIT_STORAGE_OPTIONS = EnduringKey.wrap(AbstractKey.of(c -> {
EnumMap<SplitStorageType, String> map = new EnumMap<>(SplitStorageType.class);
map.put(SplitStorageType.USER, c.getString("split-storage.methods.user", "h2").toLowerCase());
map.put(SplitStorageType.GROUP, c.getString("split-storage.methods.group", "h2").toLowerCase());
map.put(SplitStorageType.TRACK, c.getString("split-storage.methods.track", "h2").toLowerCase());
map.put(SplitStorageType.UUID, c.getString("split-storage.methods.uuid", "h2").toLowerCase());
map.put(SplitStorageType.LOG, c.getString("split-storage.methods.log", "h2").toLowerCase());
return ImmutableMap.copyOf(map);
}));
/**
common/src/main/java/me/lucko/luckperms/common/model/Group.java
+5 -4
View File
@@ -63,7 +63,7 @@ public class Group extends PermissionHolder implements Identifiable<String> {
private final GroupCachedData cachedData;
@Getter
private BufferedRequest<Void> refreshBuffer;
private final BufferedRequest<Void> refreshBuffer;
public Group(String name, LuckPermsPlugin plugin) {
super(name, plugin);
@@ -118,9 +118,10 @@ public class Group extends PermissionHolder implements Identifiable<String> {
}
private CompletableFuture<Void> reloadCachedData() {
return CompletableFuture.allOf(cachedData.reloadPermissions(), cachedData.reloadMeta()).thenAccept(n -> {
getPlugin().getApiProvider().getEventFactory().handleGroupDataRecalculate(this, cachedData);
});
return CompletableFuture.allOf(
cachedData.reloadPermissions(),
cachedData.reloadMeta()
).thenAccept(n -> getPlugin().getApiProvider().getEventFactory().handleGroupDataRecalculate(this, cachedData));
}
private static final class GroupRefreshBuffer extends BufferedRequest<Void> {
common/src/main/java/me/lucko/luckperms/common/model/Track.java
+1 -1
View File
@@ -62,7 +62,7 @@ public class Track implements Identifiable<String> {
/**
* The groups within this track
*/
private List<String> groups = Collections.synchronizedList(new ArrayList<>());
private final List<String> groups = Collections.synchronizedList(new ArrayList<>());
@Getter
private final ApiTrack delegate = new ApiTrack(this);
common/src/main/java/me/lucko/luckperms/common/model/User.java
+5 -4
View File
@@ -73,7 +73,7 @@ public class User extends PermissionHolder implements Identifiable<UserIdentifie
private final UserCachedData cachedData;
@Getter
private BufferedRequest<Void> refreshBuffer;
private final BufferedRequest<Void> refreshBuffer;
@Getter
private final ApiUser delegate = new ApiUser(this);
@@ -189,9 +189,10 @@ public class User extends PermissionHolder implements Identifiable<UserIdentifie
}
public CompletableFuture<Void> reloadCachedData() {
return CompletableFuture.allOf(cachedData.reloadPermissions(), cachedData.reloadMeta()).thenAccept(n -> {
getPlugin().getApiProvider().getEventFactory().handleUserDataRecalculate(this, cachedData);
});
return CompletableFuture.allOf(
cachedData.reloadPermissions(),
cachedData.reloadMeta()
).thenAccept(n -> getPlugin().getApiProvider().getEventFactory().handleUserDataRecalculate(this, cachedData));
}
/**
common/src/main/java/me/lucko/luckperms/common/node/NodeBuilder.java
+3 -3
View File
@@ -30,7 +30,7 @@ import lombok.NonNull;
import me.lucko.luckperms.api.Contexts;
import me.lucko.luckperms.api.Node;
import me.lucko.luckperms.api.context.ContextSet;
import me.lucko.luckperms.api.context.MutableContextSet;
import me.lucko.luckperms.api.context.ImmutableContextSet;
import java.util.Map;
import java.util.Set;
@@ -40,7 +40,7 @@ import java.util.Set;
*/
class NodeBuilder implements Node.Builder {
protected String permission;
private final MutableContextSet extraContexts = MutableContextSet.create();
private final ImmutableContextSet.Builder extraContexts = ImmutableContextSet.builder();
private Boolean value = true;
private boolean override = false;
private String server = null;
@@ -144,6 +144,6 @@ class NodeBuilder implements Node.Builder {
@Override
public Node build() {
return new ImmutableNode(permission, value, override, expireAt, server, world, extraContexts);
return new ImmutableNode(permission, value, override, expireAt, server, world, extraContexts.build());
}
}
common/src/main/java/me/lucko/luckperms/common/storage/SplitStorageType.java
+30
View File
@@ -0,0 +1,30 @@
/*
* This file is part of LuckPerms, licensed under the MIT License.
*
* Copyright (c) lucko (Luck) <luck@lucko.me>
* Copyright (c) contributors
*
* 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.storage;
public enum SplitStorageType {
LOG, USER, GROUP, TRACK, UUID
}
common/src/main/java/me/lucko/luckperms/common/storage/StorageFactory.java
+25 -28
View File
@@ -28,6 +28,7 @@ package me.lucko.luckperms.common.storage;
import lombok.experimental.UtilityClass;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import me.lucko.luckperms.common.config.ConfigKeys;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
@@ -46,8 +47,6 @@ import me.lucko.luckperms.common.storage.dao.sql.connection.hikari.PostgreConnec
import me.lucko.luckperms.common.utils.ImmutableCollectors;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
@@ -56,19 +55,17 @@ public class StorageFactory {
public static Set<StorageType> getRequiredTypes(LuckPermsPlugin plugin, StorageType defaultMethod) {
if (plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) {
Map<String, String> types = new HashMap<>(plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS));
types.entrySet().stream()
.filter(e -> StorageType.parse(e.getValue()) == null)
.forEach(e -> {
plugin.getLog().severe("Storage method for " + e.getKey() + " - " + e.getValue() + " not recognised. " +
"Using the default instead.");
e.setValue(defaultMethod.getIdentifiers().get(0));
});
Set<String> neededTypes = new HashSet<>();
neededTypes.addAll(types.values());
return neededTypes.stream().map(StorageType::parse).collect(ImmutableCollectors.toSet());
return plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream()
.map(e -> {
StorageType type = StorageType.parse(e.getValue());
if (type == null) {
plugin.getLog().severe("Storage method for " + e.getKey() + " - " + e.getValue() + " not recognised. " +
"Using the default instead.");
type = defaultMethod;
}
return type;
})
.collect(ImmutableCollectors.toEnumSet(StorageType.class));
} else {
String method = plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD);
StorageType type = StorageType.parse(method);
@@ -85,21 +82,21 @@ public class StorageFactory {
if (plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) {
plugin.getLog().info("Loading storage provider... [SPLIT STORAGE]");
Map<String, String> types = new HashMap<>(plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS));
types.entrySet().stream()
.filter(e -> StorageType.parse(e.getValue()) == null)
.forEach(e -> e.setValue(defaultMethod.getIdentifiers().get(0)));
Map<SplitStorageType, StorageType> mappedTypes = plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream()
.map(e -> {
StorageType type = StorageType.parse(e.getValue());
if (type == null) {
type = defaultMethod;
}
return Maps.immutableEntry(e.getKey(), type);
})
.collect(ImmutableCollectors.toEnumMap(SplitStorageType.class, Map.Entry::getKey, Map.Entry::getValue));
Set<String> neededTypes = new HashSet<>();
neededTypes.addAll(types.values());
Map<StorageType, AbstractDao> backing = mappedTypes.values().stream()
.distinct()
.collect(ImmutableCollectors.toEnumMap(StorageType.class, e -> e, e -> makeDao(e, plugin)));
Map<String, AbstractDao> backing = new HashMap<>();
for (String type : neededTypes) {
backing.put(type, makeDao(StorageType.parse(type), plugin));
}
storage = AbstractStorage.create(plugin, new SplitStorageDao(plugin, backing, types));
storage = AbstractStorage.create(plugin, new SplitStorageDao(plugin, backing, mappedTypes));
} else {
String method = plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD);
common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java
+28 -26
View File
@@ -35,6 +35,8 @@ import me.lucko.luckperms.common.model.Group;
import me.lucko.luckperms.common.model.Track;
import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.storage.SplitStorageType;
import me.lucko.luckperms.common.storage.StorageType;
import java.util.LinkedHashMap;
import java.util.List;
@@ -44,10 +46,10 @@ import java.util.Set;
import java.util.UUID;
public class SplitStorageDao extends AbstractDao {
private final Map<String, AbstractDao> backing;
private final Map<String, String> types;
public SplitStorageDao(LuckPermsPlugin plugin, Map<String, AbstractDao> backing, Map<String, String> types) {
private final Map<StorageType, AbstractDao> backing;
private final Map<SplitStorageType, StorageType> types;
public SplitStorageDao(LuckPermsPlugin plugin, Map<StorageType, AbstractDao> backing, Map<SplitStorageType, StorageType> types) {
super(plugin, "Split Storage");
this.backing = ImmutableMap.copyOf(backing);
this.types = ImmutableMap.copyOf(types);
@@ -92,18 +94,18 @@ public class SplitStorageDao extends AbstractDao {
@Override
public void logAction(LogEntry entry) throws Exception {
backing.get(types.get("log")).logAction(entry);
backing.get(types.get(SplitStorageType.LOG)).logAction(entry);
}
@Override
public Log getLog() throws Exception {
return backing.get(types.get("log")).getLog();
return backing.get(types.get(SplitStorageType.LOG)).getLog();
}
@Override
public void applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception {
String userType = types.get("user");
String groupType = types.get("group");
StorageType userType = types.get(SplitStorageType.USER);
StorageType groupType = types.get(SplitStorageType.GROUP);
backing.get(userType).applyBulkUpdate(bulkUpdate);
@@ -115,91 +117,91 @@ public class SplitStorageDao extends AbstractDao {
@Override
public User loadUser(UUID uuid, String username) throws Exception {
return backing.get(types.get("user")).loadUser(uuid, username);
return backing.get(types.get(SplitStorageType.USER)).loadUser(uuid, username);
}
@Override
public void saveUser(User user) throws Exception {
backing.get(types.get("user")).saveUser(user);
backing.get(types.get(SplitStorageType.USER)).saveUser(user);
}
@Override
public Set<UUID> getUniqueUsers() throws Exception {
return backing.get(types.get("user")).getUniqueUsers();
return backing.get(types.get(SplitStorageType.USER)).getUniqueUsers();
}
@Override
public List<HeldPermission<UUID>> getUsersWithPermission(String permission) throws Exception {
return backing.get(types.get("user")).getUsersWithPermission(permission);
return backing.get(types.get(SplitStorageType.USER)).getUsersWithPermission(permission);
}
@Override
public Group createAndLoadGroup(String name) throws Exception {
return backing.get(types.get("group")).createAndLoadGroup(name);
return backing.get(types.get(SplitStorageType.GROUP)).createAndLoadGroup(name);
}
@Override
public Optional<Group> loadGroup(String name) throws Exception {
return backing.get(types.get("group")).loadGroup(name);
return backing.get(types.get(SplitStorageType.GROUP)).loadGroup(name);
}
@Override
public void loadAllGroups() throws Exception {
backing.get(types.get("group")).loadAllGroups();
backing.get(types.get(SplitStorageType.GROUP)).loadAllGroups();
}
@Override
public void saveGroup(Group group) throws Exception {
backing.get(types.get("group")).saveGroup(group);
backing.get(types.get(SplitStorageType.GROUP)).saveGroup(group);
}
@Override
public void deleteGroup(Group group) throws Exception {
backing.get(types.get("group")).deleteGroup(group);
backing.get(types.get(SplitStorageType.GROUP)).deleteGroup(group);
}
@Override
public List<HeldPermission<String>> getGroupsWithPermission(String permission) throws Exception {
return backing.get(types.get("group")).getGroupsWithPermission(permission);
return backing.get(types.get(SplitStorageType.GROUP)).getGroupsWithPermission(permission);
}
@Override
public Track createAndLoadTrack(String name) throws Exception {
return backing.get(types.get("track")).createAndLoadTrack(name);
return backing.get(types.get(SplitStorageType.TRACK)).createAndLoadTrack(name);
}
@Override
public Optional<Track> loadTrack(String name) throws Exception {
return backing.get(types.get("track")).loadTrack(name);
return backing.get(types.get(SplitStorageType.TRACK)).loadTrack(name);
}
@Override
public void loadAllTracks() throws Exception {
backing.get(types.get("track")).loadAllTracks();
backing.get(types.get(SplitStorageType.TRACK)).loadAllTracks();
}
@Override
public void saveTrack(Track track) throws Exception {
backing.get(types.get("track")).saveTrack(track);
backing.get(types.get(SplitStorageType.TRACK)).saveTrack(track);
}
@Override
public void deleteTrack(Track track) throws Exception {
backing.get(types.get("track")).deleteTrack(track);
backing.get(types.get(SplitStorageType.TRACK)).deleteTrack(track);
}
@Override
public void saveUUIDData(UUID uuid, String username) throws Exception {
backing.get(types.get("uuid")).saveUUIDData(uuid, username);
backing.get(types.get(SplitStorageType.UUID)).saveUUIDData(uuid, username);
}
@Override
public UUID getUUID(String username) throws Exception {
return backing.get(types.get("uuid")).getUUID(username);
return backing.get(types.get(SplitStorageType.UUID)).getUUID(username);
}
@Override
public String getName(UUID uuid) throws Exception {
return backing.get(types.get("uuid")).getName(uuid);
return backing.get(types.get(SplitStorageType.UUID)).getName(uuid);
}
}
common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyYamlMigration.java
+2 -4
View File
@@ -109,9 +109,8 @@ public class LegacyYamlMigration implements Runnable {
Map<String, Object> data = readMapFromFile(oldFile);
Map<String, Boolean> perms = new HashMap<>();
String name = (String) data.get("name");
perms.putAll((Map<String, Boolean>) data.get("perms"));
Map<String, Boolean> perms = new HashMap<>((Map<String, Boolean>) data.get("perms"));
Set<NodeModel> nodes = perms.entrySet().stream()
.map(e -> LegacyNodeFactory.fromLegacyString(e.getKey(), e.getValue()))
@@ -154,11 +153,10 @@ public class LegacyYamlMigration implements Runnable {
Map<String, Object> data = readMapFromFile(oldFile);
Map<String, Boolean> perms = new HashMap<>();
String uuid = (String) data.get("uuid");
String name = (String) data.get("name");
String primaryGroup = (String) data.get("primary-group");
perms.putAll((Map<String, Boolean>) data.get("perms"));
Map<String, Boolean> perms = new HashMap<>((Map<String, Boolean>) data.get("perms"));
Set<NodeModel> nodes = perms.entrySet().stream()
.map(e -> LegacyNodeFactory.fromLegacyString(e.getKey(), e.getValue()))
common/src/main/java/me/lucko/luckperms/common/utils/ImmutableCollectors.java
+21
View File
@@ -31,6 +31,8 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.function.Function;
import java.util.stream.Collector;
@@ -61,6 +63,16 @@ public class ImmutableCollectors {
return (Collector) SET;
}
public static <T extends Enum<T>> Collector<T, EnumSet<T>, ImmutableSet<T>> toEnumSet(Class<T> clazz) {
//noinspection unchecked
return Collector.of(
() -> EnumSet.noneOf(clazz),
EnumSet::add,
(l, r) -> { l.addAll(r); return l; },
ImmutableSet::copyOf
);
}
public static <T, K, V> Collector<T, ImmutableMap.Builder<K, V>, ImmutableMap<K, V>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) {
return Collector.of(
ImmutableMap.Builder<K, V>::new,
@@ -70,4 +82,13 @@ public class ImmutableCollectors {
);
}
public static <T, K extends Enum<K>, V> Collector<T, EnumMap<K, V>, ImmutableMap<K, V>> toEnumMap(Class<K> clazz, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) {
return Collector.of(
() -> new EnumMap<>(clazz),
(r, t) -> r.put(keyMapper.apply(t), valueMapper.apply(t)),
(l, r) -> { l.putAll(r); return l; },
ImmutableMap::copyOf
);
}
}