502647092/Residence
1
0
Fork 0
mirror of https://e.coding.net/circlecloud/Residence.git synced 2025-11-25 21:56:06 +00:00
Code Releases Activity

remove static class...

Browse Source 
Signed-off-by: 502647092 <jtb1@163.com>
This commit is contained in:
502647092
2015-09-24 18:11:35 +08:00
parent 6b0f5ac789
commit 1cffbc7687
48 changed files with 4273 additions and 5120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

328
src/main/java/com/bekvon/bukkit/residence/protection/FlagPermissions.java
View File

@@ -27,18 +27,19 @@ import com.bekvon.bukkit.residence.Residence;
*/
public class FlagPermissions {
protected static ArrayList<String> validAreaFlags = new ArrayList<String>();
protected static HashMap<String, ArrayList<String>> validFlagGroups = new HashMap<String, ArrayList<String>>();
protected static ArrayList<String> validFlags = new ArrayList<String>();
protected static ArrayList<String> validPlayerFlags = new ArrayList<String>();
protected static ArrayList<String> validAreaFlags = new ArrayList<String>();
final static Map<Material, String> matUseFlagList = new EnumMap<Material, String>(Material.class);
protected static HashMap<String, ArrayList<String>> validFlagGroups = new HashMap<String, ArrayList<String>>();
protected Map<String, Map<String, Boolean>> playerFlags;
protected Map<String, Map<String, Boolean>> groupFlags;
static Residence plugin;
protected Map<String, Boolean> cuboidFlags;
protected Map<String, Map<String, Boolean>> groupFlags;
protected FlagPermissions parent;
protected Map<String, Map<String, Boolean>> playerFlags;
public FlagPermissions() {
public FlagPermissions(final Residence plugin) {
FlagPermissions.plugin = plugin;
cuboidFlags = Collections.synchronizedMap(new HashMap<String, Boolean>());
playerFlags = Collections.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
groupFlags = Collections.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
@@ -46,42 +47,49 @@ public class FlagPermissions {
public static void addFlag(String flag) {
flag = flag.toLowerCase();
if (!validFlags.contains(flag))
if (!validFlags.contains(flag)) {
validFlags.add(flag);
if (validFlagGroups.containsKey(flag))
}
if (validFlagGroups.containsKey(flag)) {
validFlagGroups.remove(flag);
}
}
public static void addFlagToFlagGroup(String group, String flag) {
public static void addFlagToFlagGroup(final String group, final String flag) {
if (!FlagPermissions.validFlags.contains(group) && !FlagPermissions.validAreaFlags.contains(group) && !FlagPermissions.validPlayerFlags.contains(group)) {
if (!validFlagGroups.containsKey(group))
if (!validFlagGroups.containsKey(group)) {
validFlagGroups.put(group, new ArrayList<String>());
ArrayList<String> flags = validFlagGroups.get(group);
}
final ArrayList<String> flags = validFlagGroups.get(group);
flags.add(flag);
}
}
public static void addMaterialToUseFlag(Material mat, String flag) {
public static void addMaterialToUseFlag(final Material mat, final String flag) {
matUseFlagList.put(mat, flag);
}
public static void addPlayerOrGroupOnlyFlag(String flag) {
flag = flag.toLowerCase();
if (!validPlayerFlags.contains(flag))
if (!validPlayerFlags.contains(flag)) {
validPlayerFlags.add(flag);
if (validFlagGroups.containsKey(flag))
}
if (validFlagGroups.containsKey(flag)) {
validFlagGroups.remove(flag);
}
}
public static void addResidenceOnlyFlag(String flag) {
flag = flag.toLowerCase();
if (!validAreaFlags.contains(flag))
if (!validAreaFlags.contains(flag)) {
validAreaFlags.add(flag);
if (validFlagGroups.containsKey(flag))
}
if (validFlagGroups.containsKey(flag)) {
validFlagGroups.remove(flag);
}
}
public static boolean flagGroupExists(String group) {
public static boolean flagGroupExists(final String group) {
return validFlagGroups.containsKey(group);
}
@@ -173,7 +181,7 @@ public class FlagPermissions {
addMaterialToUseFlag(Material.WORKBENCH, "table");
addMaterialToUseFlag(Material.WOODEN_DOOR, "door");
if (Residence.is1_8()) {
if (plugin.is1_8()) {
/* 1.8 Doors */
addMaterialToUseFlag(Material.SPRUCE_DOOR, "door");
addMaterialToUseFlag(Material.BIRCH_DOOR, "door");
@@ -216,66 +224,73 @@ public class FlagPermissions {
addMaterialToUseFlag(Material.CAKE_BLOCK, "cake");
}
public static FlagPermissions load(Map<String, Object> root) throws Exception {
FlagPermissions newperms = new FlagPermissions();
public static FlagPermissions load(final Map<String, Object> root) throws Exception {
final FlagPermissions newperms = new FlagPermissions(plugin);
return FlagPermissions.load(root, newperms);
}
public static FlagPermissions parseFromConfigNode(String name, ConfigurationSection node) {
FlagPermissions list = new FlagPermissions();
Set<String> keys = node.getConfigurationSection(name).getKeys(false);
if (keys != null)
public static FlagPermissions parseFromConfigNode(final String name, final ConfigurationSection node) {
final FlagPermissions list = new FlagPermissions(plugin);
final Set<String> keys = node.getConfigurationSection(name).getKeys(false);
if (keys != null) {
for (String key : keys) {
boolean state = node.getBoolean(name + "." + key, false);
final boolean state = node.getBoolean(name + "." + key, false);
key = key.toLowerCase();
if (state)
if (state) {
list.setFlag(key, FlagState.TRUE);
else
} else {
list.setFlag(key, FlagState.FALSE);
}
}
}
return list;
}
public static void removeFlagFromFlagGroup(String group, String flag) {
public static void removeFlagFromFlagGroup(final String group, final String flag) {
if (validFlagGroups.containsKey(group)) {
ArrayList<String> flags = validFlagGroups.get(group);
final ArrayList<String> flags = validFlagGroups.get(group);
flags.remove(flag);
if (flags.isEmpty())
if (flags.isEmpty()) {
validFlagGroups.remove(group);
}
}
}
public static void removeMaterialFromUseFlag(Material mat) {
public static void removeMaterialFromUseFlag(final Material mat) {
matUseFlagList.remove(mat);
}
public static FlagState stringToFlagState(String flagstate) {
if (flagstate.equalsIgnoreCase("true") || flagstate.equalsIgnoreCase("t"))
public static FlagState stringToFlagState(final String flagstate) {
if (flagstate.equalsIgnoreCase("true") || flagstate.equalsIgnoreCase("t")) {
return FlagState.TRUE;
else if (flagstate.equalsIgnoreCase("false") || flagstate.equalsIgnoreCase("f"))
} else if (flagstate.equalsIgnoreCase("false") || flagstate.equalsIgnoreCase("f")) {
return FlagState.FALSE;
else if (flagstate.equalsIgnoreCase("remove") || flagstate.equalsIgnoreCase("r"))
} else if (flagstate.equalsIgnoreCase("remove") || flagstate.equalsIgnoreCase("r")) {
return FlagState.NEITHER;
else
} else {
return FlagState.INVALID;
}
}
@SuppressWarnings("unchecked")
protected static FlagPermissions load(Map<String, Object> root, FlagPermissions newperms) throws Exception {
protected static FlagPermissions load(final Map<String, Object> root, final FlagPermissions newperms) throws Exception {
newperms.playerFlags = (Map<String, Map<String, Boolean>>) root.get("PlayerFlags");
newperms.groupFlags = (Map<String, Map<String, Boolean>>) root.get("GroupFlags");
newperms.cuboidFlags = (Map<String, Boolean>) root.get("AreaFlags");
return newperms;
}
public boolean checkValidFlag(String flag, boolean globalflag) {
if (validFlags.contains(flag))
public boolean checkValidFlag(final String flag, final boolean globalflag) {
if (validFlags.contains(flag)) {
return true;
}
if (globalflag) {
if (validAreaFlags.contains(flag))
if (validAreaFlags.contains(flag)) {
return true;
} else if (validPlayerFlags.contains(flag))
}
} else if (validPlayerFlags.contains(flag)) {
return true;
}
return false;
}
@@ -285,23 +300,25 @@ public class FlagPermissions {
cuboidFlags.clear();
}
public void clearPlayersFlags(String user) {
if (playerFlags.containsKey(user))
public void clearPlayersFlags(final String user) {
if (playerFlags.containsKey(user)) {
playerFlags.remove(user);
}
}
public void copyUserPermissions(String fromUser, String toUser) {
fromUser = fromUser.toLowerCase();
toUser = toUser.toLowerCase();
Map<String, Boolean> get = playerFlags.get(fromUser);
final Map<String, Boolean> get = playerFlags.get(fromUser);
if (get != null) {
Map<String, Boolean> targ = playerFlags.get(toUser);
if (targ == null) {
targ = new HashMap<String, Boolean>();
playerFlags.put(toUser, targ);
}
for (Entry<String, Boolean> entry : get.entrySet())
for (final Entry<String, Boolean> entry : get.entrySet()) {
targ.put(entry.getKey(), entry.getValue());
}
}
}
@@ -309,91 +326,101 @@ public class FlagPermissions {
return parent;
}
public boolean groupHas(String group, String flag, boolean def) {
public boolean groupHas(final String group, final String flag, final boolean def) {
return this.groupCheck(group, flag, this.has(flag, def));
}
public boolean has(String flag, boolean def) {
if (cuboidFlags.containsKey(flag))
public boolean has(final String flag, final boolean def) {
if (cuboidFlags.containsKey(flag)) {
return cuboidFlags.get(flag);
if (parent != null)
}
if (parent != null) {
return parent.has(flag, def);
}
return def;
}
public boolean inheritanceIsGroupSet(String group, String flag) {
public boolean inheritanceIsGroupSet(String group, final String flag) {
group = group.toLowerCase();
Map<String, Boolean> flags = groupFlags.get(group);
if (flags == null)
final Map<String, Boolean> flags = groupFlags.get(group);
if (flags == null) {
return parent == null ? false : parent.inheritanceIsGroupSet(group, flag);
}
return flags.containsKey(flag) ? true : parent == null ? false : parent.inheritanceIsGroupSet(group, flag);
}
public boolean inheritanceIsPlayerSet(String player, String flag) {
public boolean inheritanceIsPlayerSet(String player, final String flag) {
player = player.toLowerCase();
Map<String, Boolean> flags = playerFlags.get(player);
if (flags == null)
final Map<String, Boolean> flags = playerFlags.get(player);
if (flags == null) {
return parent == null ? false : parent.inheritanceIsPlayerSet(player, flag);
}
return flags.containsKey(flag) ? true : parent == null ? false : parent.inheritanceIsPlayerSet(player, flag);
}
public boolean inheritanceIsSet(String flag) {
public boolean inheritanceIsSet(final String flag) {
return cuboidFlags.containsKey(flag) ? true : parent == null ? false : parent.inheritanceIsSet(flag);
}
public boolean isGroupSet(String group, String flag) {
public boolean isGroupSet(String group, final String flag) {
group = group.toLowerCase();
Map<String, Boolean> flags = groupFlags.get(group);
if (flags == null)
final Map<String, Boolean> flags = groupFlags.get(group);
if (flags == null) {
return false;
}
return flags.containsKey(flag);
}
public boolean isPlayerSet(String player, String flag) {
public boolean isPlayerSet(String player, final String flag) {
player = player.toLowerCase();
Map<String, Boolean> flags = playerFlags.get(player);
if (flags == null)
final Map<String, Boolean> flags = playerFlags.get(player);
if (flags == null) {
return false;
}
return flags.containsKey(flag);
}
public boolean isSet(String flag) {
public boolean isSet(final String flag) {
return cuboidFlags.containsKey(flag);
}
public String listFlags() {
StringBuilder sbuild = new StringBuilder();
Set<Entry<String, Boolean>> set = cuboidFlags.entrySet();
final StringBuilder sbuild = new StringBuilder();
final Set<Entry<String, Boolean>> set = cuboidFlags.entrySet();
synchronized (cuboidFlags) {
Iterator<Entry<String, Boolean>> it = set.iterator();
final Iterator<Entry<String, Boolean>> it = set.iterator();
while (it.hasNext()) {
Entry<String, Boolean> next = it.next();
final Entry<String, Boolean> next = it.next();
if (next.getValue()) {
sbuild.append("+").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
} else {
sbuild.append("-").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
}
}
}
if (sbuild.length() == 0)
if (sbuild.length() == 0) {
sbuild.append("none");
}
return sbuild.toString();
}
public String listGroupFlags() {
StringBuilder sbuild = new StringBuilder();
Set<String> set = groupFlags.keySet();
final StringBuilder sbuild = new StringBuilder();
final Set<String> set = groupFlags.keySet();
synchronized (groupFlags) {
Iterator<String> it = set.iterator();
final Iterator<String> it = set.iterator();
while (it.hasNext()) {
String next = it.next();
String perms = listGroupFlags(next);
if (!perms.equals("none"))
final String next = it.next();
final String perms = listGroupFlags(next);
if (!perms.equals("none")) {
sbuild.append(next).append("[" + ChatColor.DARK_AQUA).append(perms).append(ChatColor.RED + "] ");
}
}
}
return sbuild.toString();
@@ -402,21 +429,23 @@ public class FlagPermissions {
public String listGroupFlags(String group) {
group = group.toLowerCase();
if (groupFlags.containsKey(group)) {
StringBuilder sbuild = new StringBuilder();
Map<String, Boolean> get = groupFlags.get(group);
Set<Entry<String, Boolean>> set = get.entrySet();
final StringBuilder sbuild = new StringBuilder();
final Map<String, Boolean> get = groupFlags.get(group);
final Set<Entry<String, Boolean>> set = get.entrySet();
synchronized (get) {
Iterator<Entry<String, Boolean>> it = set.iterator();
final Iterator<Entry<String, Boolean>> it = set.iterator();
while (it.hasNext()) {
Entry<String, Boolean> next = it.next();
final Entry<String, Boolean> next = it.next();
if (next.getValue()) {
sbuild.append("+").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
} else {
sbuild.append("-").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
}
}
}
@@ -425,22 +454,24 @@ public class FlagPermissions {
sbuild.append("none");
}
return sbuild.toString();
} else
} else {
return "none";
}
}
public String listOtherPlayersFlags(String player) {
player = player.toLowerCase();
StringBuilder sbuild = new StringBuilder();
Set<String> set = playerFlags.keySet();
final StringBuilder sbuild = new StringBuilder();
final Set<String> set = playerFlags.keySet();
synchronized (playerFlags) {
Iterator<String> it = set.iterator();
final Iterator<String> it = set.iterator();
while (it.hasNext()) {
String next = it.next();
final String next = it.next();
if (!next.equals(player)) {
String perms = listPlayerFlags(next);
if (!perms.equals("none"))
final String perms = listPlayerFlags(next);
if (!perms.equals("none")) {
sbuild.append(next).append("[" + ChatColor.DARK_AQUA).append(perms).append(ChatColor.RED + "] ");
}
}
}
}
@@ -450,21 +481,23 @@ public class FlagPermissions {
public String listPlayerFlags(String player) {
player = player.toLowerCase();
if (playerFlags.containsKey(player)) {
StringBuilder sbuild = new StringBuilder();
Map<String, Boolean> get = playerFlags.get(player);
Set<Entry<String, Boolean>> set = get.entrySet();
final StringBuilder sbuild = new StringBuilder();
final Map<String, Boolean> get = playerFlags.get(player);
final Set<Entry<String, Boolean>> set = get.entrySet();
synchronized (get) {
Iterator<Entry<String, Boolean>> it = set.iterator();
final Iterator<Entry<String, Boolean>> it = set.iterator();
while (it.hasNext()) {
Entry<String, Boolean> next = it.next();
final Entry<String, Boolean> next = it.next();
if (next.getValue()) {
sbuild.append("+").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
} else {
sbuild.append("-").append(next.getKey());
if (it.hasNext())
if (it.hasNext()) {
sbuild.append(" ");
}
}
}
}
@@ -473,115 +506,130 @@ public class FlagPermissions {
sbuild.append("none");
}
return sbuild.toString();
} else
} else {
return "none";
}
}
public boolean playerHas(String player, String world, String flag, boolean def) {
String group = Residence.getPermissionManager().getGroupNameByPlayer(player, world);
public boolean playerHas(final String player, final String world, final String flag, final boolean def) {
final String group = plugin.getPermissionManager().getGroupNameByPlayer(player, world);
return this.playerCheck(player, flag, this.groupCheck(group, flag, this.has(flag, def)));
}
public void printFlags(Player player) {
player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Flags") + ":" + ChatColor.BLUE + " " + listFlags());
player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Your.Flags") + ":" + ChatColor.GREEN + " " + listPlayerFlags(player.getName()));
player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Group.Flags") + ":" + ChatColor.RED + " " + listGroupFlags());
player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Others.Flags") + ":" + ChatColor.RED + " " + listOtherPlayersFlags(player.getName()));
public void printFlags(final Player player) {
player.sendMessage(ChatColor.YELLOW + plugin.getLanguage().getPhrase("Flags") + ":" + ChatColor.BLUE + " " + listFlags());
player.sendMessage(ChatColor.YELLOW + plugin.getLanguage().getPhrase("Your.Flags") + ":" + ChatColor.GREEN + " " + listPlayerFlags(player.getName()));
player.sendMessage(ChatColor.YELLOW + plugin.getLanguage().getPhrase("Group.Flags") + ":" + ChatColor.RED + " " + listGroupFlags());
player.sendMessage(ChatColor.YELLOW + plugin.getLanguage().getPhrase("Others.Flags") + ":" + ChatColor.RED + " " + listOtherPlayersFlags(player.getName()));
}
public void removeAllGroupFlags(String group) {
public void removeAllGroupFlags(final String group) {
groupFlags.remove(group);
}
public void removeAllPlayerFlags(String player) {
public void removeAllPlayerFlags(final String player) {
playerFlags.remove(player);
}
public Map<String, Object> save() {
Map<String, Object> root = new LinkedHashMap<String, Object>();
final Map<String, Object> root = new LinkedHashMap<String, Object>();
root.put("PlayerFlags", playerFlags);
root.put("GroupFlags", groupFlags);
root.put("AreaFlags", cuboidFlags);
return root;
}
public boolean setFlag(String flag, FlagState state) {
if (state == FlagState.FALSE)
public boolean setFlag(final String flag, final FlagState state) {
if (state == FlagState.FALSE) {
cuboidFlags.put(flag, false);
else if (state == FlagState.TRUE)
} else if (state == FlagState.TRUE) {
cuboidFlags.put(flag, true);
else if (state == FlagState.NEITHER)
if (cuboidFlags.containsKey(flag))
} else if (state == FlagState.NEITHER) {
if (cuboidFlags.containsKey(flag)) {
cuboidFlags.remove(flag);
}
}
return true;
}
public boolean setGroupFlag(String group, String flag, FlagState state) {
public boolean setGroupFlag(String group, final String flag, final FlagState state) {
group = group.toLowerCase();
if (!groupFlags.containsKey(group))
if (!groupFlags.containsKey(group)) {
groupFlags.put(group, Collections.synchronizedMap(new HashMap<String, Boolean>()));
Map<String, Boolean> map = groupFlags.get(group);
if (state == FlagState.FALSE)
}
final Map<String, Boolean> map = groupFlags.get(group);
if (state == FlagState.FALSE) {
map.put(flag, false);
else if (state == FlagState.TRUE)
} else if (state == FlagState.TRUE) {
map.put(flag, true);
else if (state == FlagState.NEITHER)
if (map.containsKey(flag))
} else if (state == FlagState.NEITHER) {
if (map.containsKey(flag)) {
map.remove(flag);
if (map.isEmpty())
}
}
if (map.isEmpty()) {
groupFlags.remove(group);
}
return true;
}
public void setParent(FlagPermissions p) {
public void setParent(final FlagPermissions p) {
parent = p;
}
public boolean setPlayerFlag(String player, String flag, FlagState state) {
public boolean setPlayerFlag(String player, final String flag, final FlagState state) {
player = player.toLowerCase();
if (!playerFlags.containsKey(player))
if (!playerFlags.containsKey(player)) {
playerFlags.put(player, Collections.synchronizedMap(new HashMap<String, Boolean>()));
Map<String, Boolean> map = playerFlags.get(player);
if (state == FlagState.FALSE)
}
final Map<String, Boolean> map = playerFlags.get(player);
if (state == FlagState.FALSE) {
map.put(flag, false);
else if (state == FlagState.TRUE)
} else if (state == FlagState.TRUE) {
map.put(flag, true);
else if (state == FlagState.NEITHER)
if (map.containsKey(flag))
} else if (state == FlagState.NEITHER) {
if (map.containsKey(flag)) {
map.remove(flag);
if (map.isEmpty())
}
}
if (map.isEmpty()) {
playerFlags.remove(player);
}
return true;
}
private boolean groupCheck(String group, String flag, boolean def) {
private boolean groupCheck(final String group, final String flag, final boolean def) {
if (groupFlags.containsKey(group)) {
Map<String, Boolean> gmap = groupFlags.get(group);
if (gmap.containsKey(flag))
final Map<String, Boolean> gmap = groupFlags.get(group);
if (gmap.containsKey(flag)) {
return gmap.get(flag);
}
}
if (parent != null)
if (parent != null) {
return parent.groupCheck(group, flag, def);
}
return def;
}
private boolean playerCheck(String player, String flag, boolean def) {
private boolean playerCheck(String player, final String flag, final boolean def) {
player = player.toLowerCase();
if (playerFlags.containsKey(player)) {
Map<String, Boolean> pmap = playerFlags.get(player);
if (pmap.containsKey(flag))
final Map<String, Boolean> pmap = playerFlags.get(player);
if (pmap.containsKey(flag)) {
return pmap.get(flag);
}
}
if (parent != null)
if (parent != null) {
return parent.playerCheck(player, flag, def);
}
return def;
}
public static enum FlagState {
TRUE,
FALSE,
INVALID,
NEITHER,
INVALID
TRUE
}
}