EpicKnarvik97/PlotSquared
1
0
Fork 0
mirror of https://github.com/IntellectualSites/PlotSquared.git synced 2025-07-01 21:24:43 +02:00
Code Issues Projects Releases Wiki Activity

Hows this?

Browse Source
This commit is contained in:
boy0001
2015-09-13 14:04:31 +10:00
parent 1cccdd9d4d
commit 5137b23357
379 changed files with 18471 additions and 28437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/main/java/com/intellectualcrafters/plot/flag/AbstractFlag.java
View File

@ -26,91 +26,84 @@ import com.intellectualcrafters.plot.util.StringMan;
* Created 2014-09-23 for PlotSquared
*
*/
*/
public class AbstractFlag {
public final String key;
public final FlagValue<?> value;
public final String key;
public final FlagValue<?> value;
public AbstractFlag(final String key) {
this(key, new FlagValue.StringValue());
this(key, new FlagValue.StringValue());
}
/**
* AbstractFlag is a parameter used in creating a new Flag<br>
* The key must be alphabetical characters and &lt;= 16 characters in length
* @param key
*/
public AbstractFlag(final String key, final FlagValue<?> value)
{
if (!StringMan.isAlpha(key.replaceAll("_", "").replaceAll("-", ""))) { throw new IllegalArgumentException("Flag must be alphabetic characters"); }
if (key.length() > 16) { throw new IllegalArgumentException("Key must be <= 16 characters"); }
this.key = key.toLowerCase();
if (value == null)
* @param key
*/
public AbstractFlag(final String key, final FlagValue<?> value) {
if (!StringMan.isAlpha(key.replaceAll("_", "").replaceAll("-", ""))) {
this.value = new FlagValue.StringValue();
}
throw new IllegalArgumentException("Flag must be alphabetic characters");
}
if (key.length() > 16) {
throw new IllegalArgumentException("Key must be <= 16 characters");
}
this.key = key.toLowerCase();
if (value == null) {
this.value = new FlagValue.StringValue();
} else {
this.value = value;
}
}
}
}
public boolean isList() {
return value instanceof FlagValue.ListValue;
}
public Object parseValueRaw(final String value)
{
return value instanceof FlagValue.ListValue;
}
public Object parseValueRaw(final String value) {
{
return this.value.parse(value);
}
try {
return this.value.parse(value);
} catch (final Exception e) {
return null;
}
}
}
}
public String toString(final Object t) {
return value.toString(t);
}
return value.toString(t);
}
public String getValueDesc() {
return value.getDescription();
return value.getDescription();
}
/**
* AbstractFlag key
*
* @return String
*/
* @return String
*/
public String getKey() {
return key;
return key;
}
@Override
@Override
public String toString() {
return key;
return key;
}
@Override
@Override
public int hashCode() {
return key.hashCode();
return key.hashCode();
}
@Override
public boolean equals(final Object other)
{
if (other == null) { return false; }
@Override
public boolean equals(final Object other) {
if (other == null) {
return false;
}
if (other == this) {
return true;
}
if (!(other instanceof AbstractFlag)) {
return false;
}
final AbstractFlag otherObj = (AbstractFlag) other;

84
src/main/java/com/intellectualcrafters/plot/flag/Flag.java
View File

@ -22,11 +22,10 @@ package com.intellectualcrafters.plot.flag;
import com.intellectualcrafters.plot.util.StringMan;
public class Flag
{
public class Flag {
private AbstractFlag key;
private Object value;
/**
* Flag object used to store basic information for a Plot. Flags are a key/value pair. For a flag to be usable by a
* player, you need to register it with PlotSquared.
@ -36,88 +35,91 @@ public class Flag
*
* @throws IllegalArgumentException if you provide inadequate inputs
*/
public Flag(final AbstractFlag key, final String value)
{
if (!StringMan.isAsciiPrintable(value)) { throw new IllegalArgumentException("Flag must be ascii"); }
if (value.length() > 128) { throw new IllegalArgumentException("Value must be <= 128 characters"); }
public Flag(final AbstractFlag key, final String value) {
if (!StringMan.isAsciiPrintable(value)) {
throw new IllegalArgumentException("Flag must be ascii");
}
if (value.length() > 128) {
throw new IllegalArgumentException("Value must be <= 128 characters");
}
this.key = key;
this.value = key.parseValueRaw(value);
if (this.value == null) { throw new IllegalArgumentException(key.getValueDesc() + " (" + value + ")"); }
if (this.value == null) {
throw new IllegalArgumentException(key.getValueDesc() + " (" + value + ")");
}
}
public void setKey(final AbstractFlag key)
{
public void setKey(final AbstractFlag key) {
this.key = key;
if (value instanceof String)
{
if (value instanceof String) {
value = key.parseValueRaw((String) value);
}
}
/**
* Warning: Unchecked
*/
public Flag(final AbstractFlag key, final Object value)
{
public Flag(final AbstractFlag key, final Object value) {
this.key = key;
this.value = value;
}
/**
* Get the AbstractFlag used in creating the flag
*
* @return AbstractFlag
*/
public AbstractFlag getAbstractFlag()
{
public AbstractFlag getAbstractFlag() {
return key;
}
/**
* Get the key for the AbstractFlag
*
* @return String
*/
public String getKey()
{
public String getKey() {
return key.getKey();
}
/**
* Get the value
*
* @return String
*/
public Object getValue()
{
public Object getValue() {
return value;
}
public String getValueString()
{
public String getValueString() {
return key.toString(value);
}
@Override
public String toString()
{
if (value.equals("")) { return key.getKey(); }
public String toString() {
if (value.equals("")) {
return key.getKey();
}
return key + ":" + getValueString();
}
@Override
public boolean equals(final Object obj)
{
if (this == obj) { return true; }
if (obj == null) { return false; }
if (getClass() != obj.getClass()) { return false; }
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Flag other = (Flag) obj;
return (key.getKey().equals(other.key.getKey()) && value.equals(other.value));
}
@Override
public int hashCode()
{
public int hashCode() {
return key.getKey().hashCode();
}
}

343
src/main/java/com/intellectualcrafters/plot/flag/FlagManager.java
View File

@ -44,54 +44,49 @@ import com.intellectualcrafters.plot.util.Permissions;
*
*/
@SuppressWarnings("unused")
*/
@SuppressWarnings("unused")
public class FlagManager {
// TODO add some flags
// - Plot clear interval
// - Mob cap
// - Mob cap
// - customized plot composition
private final static HashSet<String> reserved = new HashSet<>();
private final static HashSet<AbstractFlag> flags = new HashSet<>();
/**
* Reserve a flag so that it cannot be set by players
* @param flag
*/
* @param flag
*/
public static void reserveFlag(final String flag) {
reserved.add(flag);
reserved.add(flag);
}
/**
* Get if a flag is reserved
* @param flag
* @return
*/
* @return
*/
public static boolean isReserved(final String flag) {
return reserved.contains(flag);
return reserved.contains(flag);
}
/**
* Get the reserved flags
* @return
*/
* @return
*/
public static HashSet<String> getReservedFlags() {
return (HashSet<String>) reserved.clone();
return (HashSet<String>) reserved.clone();
}
/**
* Unreserve a flag
* @param flag
*/
* @param flag
*/
public static void unreserveFlag(final String flag) {
reserved.remove(flag);
reserved.remove(flag);
}
/**
@ -99,193 +94,188 @@ public class FlagManager
*
* @param af Flag to register
*
* @return boolean success
*/
* @return boolean success
*/
public static boolean addFlag(final AbstractFlag af) {
return addFlag(af, false);
}
return addFlag(af, false);
}
{
PS.debug(C.PREFIX.s() + "&8 - Adding flag: &7" + af);
public static boolean addFlag(final AbstractFlag af, final boolean reserved) {
PS.debug(C.PREFIX.s() + "&8 - Adding flag: &7" + af);
{
final Flag flag = ((HashMap<String, Flag>) plotworld.DEFAULT_FLAGS.clone()).get(af.getKey());
for (final PlotWorld plotworld : PS.get().getPlotWorldObjects()) {
final Flag flag = ((HashMap<String, Flag>) plotworld.DEFAULT_FLAGS.clone()).get(af.getKey());
if (flag != null) {
flag.setKey(af);
}
}
if (PS.get().getAllPlotsRaw() != null)
{
}
}
if (PS.get().getAllPlotsRaw() != null) {
{
final Flag flag = plot.getSettings().flags.get(af.getKey());
for (final Plot plot : PS.get().getPlotsRaw()) {
final Flag flag = plot.getSettings().flags.get(af.getKey());
if (flag != null) {
flag.setKey(af);
}
}
}
if ((getFlag(af.getKey()) == null) && flags.add(af))
{
}
}
if ((getFlag(af.getKey()) == null) && flags.add(af)) {
if (reserved) {
reserveFlag(af.getKey());
}
return true;
}
return false;
}
return false;
}
{
Flag flag;
public static Flag getSettingFlag(final String world, final PlotSettings settings, final String id) {
Flag flag;
{
final PlotWorld plotworld = PS.get().getPlotWorld(world);
if ((settings.flags.size() == 0) || ((flag = settings.flags.get(id)) == null)) {
final PlotWorld plotworld = PS.get().getPlotWorld(world);
if (plotworld == null) {
return null;
}
if (plotworld.DEFAULT_FLAGS.size() == 0) {
return null;
}
return ((HashMap<String, Flag>) plotworld.DEFAULT_FLAGS.clone()).get(id);
}
return flag;
}
return flag;
}
{
public static boolean isBooleanFlag(final Plot plot, final String key, final boolean defaultValue) {
final Flag flag = FlagManager.getPlotFlag(plot, key);
if (flag == null) {
return defaultValue;
if (flag == null) { return defaultValue; }
}
final Object value = flag.getValue();
if (value instanceof Boolean) {
return (boolean) value;
}
return defaultValue;
return defaultValue;
}
/**
* Get the value of a flag for a plot (respects flag defaults)
* @param plot
* @param flag
* @return Flag
*/
public static Flag getPlotFlag(final Plot plot, final String flag)
* @return Flag
*/
public static Flag getPlotFlag(final Plot plot, final String flag) {
if (!plot.hasOwner()) {
return null;
}
return getSettingFlag(plot.world, plot.getSettings(), flag);
}
public static boolean isPlotFlagTrue(final Plot plot, final String strFlag)
return getSettingFlag(plot.world, plot.getSettings(), flag);
}
public static boolean isPlotFlagTrue(final Plot plot, final String strFlag) {
if (plot.owner == null) {
return false;
}
final Flag flag = getPlotFlag(plot, strFlag);
return !((flag == null) || !((Boolean) flag.getValue()));
}
public static boolean isPlotFlagFalse(final Plot plot, final String strFlag)
return !((flag == null) || !((Boolean) flag.getValue()));
}
public static boolean isPlotFlagFalse(final Plot plot, final String strFlag) {
if (plot.owner == null) {
return false;
if (plot.owner == null) { return false; }
}
final Flag flag = getPlotFlag(plot, strFlag);
if ((flag == null) || ((Boolean) flag.getValue())) {
return false;
}
return false;
return false;
}
/**
* Get the value of a flag for a plot (ignores flag defaults)
* @param plot
* @param flag
* @return Flag
*/
* @return Flag
*/
public static Flag getPlotFlagAbs(final Plot plot, final String flag) {
return getSettingFlagAbs(plot.getSettings(), flag);
}
public static Flag getSettingFlagAbs(final PlotSettings settings, final String flag)
return getSettingFlagAbs(plot.getSettings(), flag);
}
public static Flag getSettingFlagAbs(final PlotSettings settings, final String flag) {
if ((settings.flags == null) || (settings.flags.size() == 0)) {
return null;
}
return settings.flags.get(flag);
return settings.flags.get(flag);
}
/**
* Add a flag to a plot
* @param plot
* @param flag
*/
* @param flag
*/
{
public static boolean addPlotFlag(final Plot plot, final Flag flag) {
final boolean result = EventUtil.manager.callFlagAdd(flag, plot);
if (!result) {
return false;
}
plot.getSettings().flags.put(flag.getKey(), flag);
MainUtil.reEnterPlot(plot);
DBFunc.setFlags(plot, plot.getSettings().flags.values());
return true;
}
return true;
}
{
public static boolean addPlotFlagAbs(final Plot plot, final Flag flag) {
final boolean result = EventUtil.manager.callFlagAdd(flag, plot);
if (!result) {
return false;
}
plot.getSettings().flags.put(flag.getKey(), flag);
return true;
}
return true;
}
public static boolean addClusterFlag(final PlotCluster cluster, final Flag flag) {
getSettingFlag(cluster.world, cluster.settings, flag.getKey());
cluster.settings.flags.put(flag.getKey(), flag);
DBFunc.setFlags(cluster, cluster.settings.flags.values());
return true;
return true;
}
/**
*
* @param plot
* @return set of flags
*/
public static HashMap<String, Flag> getPlotFlags(final Plot plot)
* @return set of flags
*/
public static HashMap<String, Flag> getPlotFlags(final Plot plot) {
if (!plot.hasOwner()) {
return null;
}
return getSettingFlags(plot.world, plot.getSettings());
}
return getSettingFlags(plot.world, plot.getSettings());
}
{
public static HashMap<String, Flag> getPlotFlags(final String world, final PlotSettings settings, final boolean ignorePluginflags) {
final HashMap<String, Flag> flags = new HashMap<>();
final PlotWorld plotWorld = PS.get().getPlotWorld(world);
final PlotWorld plotWorld = PS.get().getPlotWorld(world);
if ((plotWorld != null) && (plotWorld.DEFAULT_FLAGS.size() != 0)) {
flags.putAll(plotWorld.DEFAULT_FLAGS);
}
if (ignorePluginflags)
{
for (final Map.Entry<String, Flag> flag : settings.flags.entrySet())
{
flags.putAll(plotWorld.DEFAULT_FLAGS);
}
if (ignorePluginflags) {
for (final Map.Entry<String, Flag> flag : settings.flags.entrySet()) {
if (isReserved(flag.getValue().getAbstractFlag().getKey())) {
continue;
}
flags.put(flag.getKey(), flag.getValue());
}
}
flags.put(flag.getKey(), flag.getValue());
}
} else {
flags.putAll(settings.flags);
flags.putAll(settings.flags);
}
return flags;
}
return flags;
}
public static HashMap<String, Flag> getSettingFlags(final String world, final PlotSettings settings) {
return getPlotFlags(world, settings, false);
}
return getPlotFlags(world, settings, false);
}
{
public static boolean removePlotFlag(final Plot plot, final String id) {
final Flag flag = plot.getSettings().flags.remove(id);
if (flag == null) {
return false;
if (flag == null) { return false; }
final boolean result = EventUtil.manager.callFlagRemove(flag, plot);
}
final boolean result = EventUtil.manager.callFlagRemove(flag, plot);
if (!result) {
plot.getSettings().flags.put(id, flag);
@ -293,101 +283,80 @@ public class FlagManager
}
MainUtil.reEnterPlot(plot);
DBFunc.setFlags(plot, plot.getSettings().flags.values());
return true;
}
return true;
}
{
public static boolean removeClusterFlag(final PlotCluster cluster, final String id) {
final Flag flag = cluster.settings.flags.remove(id);
if (flag == null) {
return false;
if (flag == null) { return false; }
final boolean result = EventUtil.manager.callFlagRemove(flag, cluster);
}
final boolean result = EventUtil.manager.callFlagRemove(flag, cluster);
if (!result) {
cluster.settings.flags.put(id, flag);
return false;
}
DBFunc.setFlags(cluster, cluster.settings.flags.values());
return true;
}
public static void setPlotFlags(final Plot plot, final Set<Flag> flags)
{
return true;
}
public static void setPlotFlags(final Plot plot, final Set<Flag> flags) {
{
plot.getSettings().flags.clear();
if ((flags != null) && (flags.size() != 0)) {
plot.getSettings().flags.clear();
for (final Flag flag : flags) {
plot.getSettings().flags.put(flag.getKey(), flag);
}
}
plot.getSettings().flags.put(flag.getKey(), flag);
}
{
return;
}
} else if (plot.getSettings().flags.size() == 0) {
return;
} else {
plot.getSettings().flags.clear();
}
MainUtil.reEnterPlot(plot);
DBFunc.setFlags(plot, plot.getSettings().flags.values());
}
public static void setClusterFlags(final PlotCluster cluster, final Set<Flag> flags)
{
DBFunc.setFlags(plot, plot.getSettings().flags.values());
}
public static void setClusterFlags(final PlotCluster cluster, final Set<Flag> flags) {
{
cluster.settings.flags.clear();
if ((flags != null) && (flags.size() != 0)) {
cluster.settings.flags.clear();
for (final Flag flag : flags) {
cluster.settings.flags.put(flag.getKey(), flag);
}
}
cluster.settings.flags.put(flag.getKey(), flag);
}
{
return;
}
} else if (cluster.settings.flags.size() == 0) {
return;
} else {
cluster.settings.flags.clear();
}
DBFunc.setFlags(cluster, cluster.settings.flags.values());
}
DBFunc.setFlags(cluster, cluster.settings.flags.values());
}
public static Flag[] removeFlag(final Flag[] flags, final String r) {
final Flag[] f = new Flag[flags.length - 1];
int index = 0;
for (final Flag flag : flags)
{
final Flag[] f = new Flag[flags.length - 1];
int index = 0;
for (final Flag flag : flags) {
if (!flag.getKey().equals(r)) {
f[index++] = flag;
}
}
return f;
}
return f;
}
{
final HashSet<Flag> newflags = new HashSet<>();
for (final Flag flag : flags)
{
public static Set<Flag> removeFlag(final Set<Flag> flags, final String r) {
final HashSet<Flag> newflags = new HashSet<>();
for (final Flag flag : flags) {
if (!flag.getKey().equalsIgnoreCase(r)) {
newflags.add(flag);
}
}
return newflags;
return newflags;
}
/**
* Get a list of registered AbstractFlag objects
*
* @return List (AbstractFlag)
*/
* @return List (AbstractFlag)
*/
public static HashSet<AbstractFlag> getFlags() {
return flags;
return flags;
}
/**
@ -395,19 +364,16 @@ public class FlagManager
*
* @param player with permissions
*
* @return List (AbstractFlag)
*/
* @return List (AbstractFlag)
*/
{
final List<AbstractFlag> returnFlags = new ArrayList<>();
for (final AbstractFlag flag : flags)
{
public static List<AbstractFlag> getFlags(final PlotPlayer player) {
final List<AbstractFlag> returnFlags = new ArrayList<>();
for (final AbstractFlag flag : flags) {
if (Permissions.hasPermission(player, "plots.set.flag." + flag.getKey().toLowerCase())) {
returnFlags.add(flag);
}
}
return returnFlags;
return returnFlags;
}
/**
@ -415,15 +381,15 @@ public class FlagManager
*
* @param string Flag Key
*
* @return AbstractFlag
*/
public static AbstractFlag getFlag(final String string)
{
for (final AbstractFlag flag : flags)
* @return AbstractFlag
*/
public static AbstractFlag getFlag(final String string) {
for (final AbstractFlag flag : flags) {
if (flag.getKey().equalsIgnoreCase(string)) {
return flag;
}
}
return null;
return null;
}
/**
@ -432,16 +398,14 @@ public class FlagManager
* @param string Flag Key
* @param create If to create the flag if it does not exist
*
* @return AbstractFlag
*/
public static AbstractFlag getFlag(final String string, final boolean create)
{
* @return AbstractFlag
*/
public static AbstractFlag getFlag(final String string, final boolean create) {
if ((getFlag(string) == null) && create) {
final AbstractFlag flag = new AbstractFlag(string);
return flag;
}
return getFlag(string);
return getFlag(string);
}
/**
@ -449,32 +413,23 @@ public class FlagManager
*
* @param flag Flag Key
*
* @return boolean Result of operation
*/
* @return boolean Result of operation
*/
public static boolean removeFlag(final AbstractFlag flag) {
return flags.remove(flag);
}
return flags.remove(flag);
}
{
final HashMap<String, Flag> map = new HashMap<String, Flag>();
public static HashMap<String, Flag> parseFlags(final List<String> flagstrings) {
final HashMap<String, Flag> map = new HashMap<String, Flag>();
{
final String[] split;
for (final String key : flagstrings) {
final String[] split;
{
split = key.split(";");
}
if (key.contains(";")) {
split = key.split(";");
} else {
split = key.split(":");
}
Flag flag;
}
Flag flag;
{
flag = new Flag(getFlag(split[0], true), "");
}
if (split.length == 1) {
flag = new Flag(getFlag(split[0], true), "");
} else {
flag = new Flag(getFlag(split[0], true), split[1]);

558
src/main/java/com/intellectualcrafters/plot/flag/FlagValue.java
View File

@ -12,398 +12,312 @@ import com.intellectualcrafters.plot.util.StringMan;
* Created 2014-11-17 for PlotSquared
*
*/
public abstract class FlagValue<T>
*/
public abstract class FlagValue<T> {
private final Class<T> clazz;
private final Class<T> clazz;
@SuppressWarnings("unchecked")
public FlagValue()
@SuppressWarnings("unchecked")
public FlagValue() {
this.clazz = (Class<T>) getClass();
}
public FlagValue(final Class<T> clazz)
{
}
public FlagValue(final Class<T> clazz) {
if (clazz == null) {
throw new NullPointerException();
}
this.clazz = clazz;
}
public boolean validValue(final Object value)
}
public boolean validValue(final Object value) {
return (value != null) && (value.getClass() == this.clazz);
}
public String toString(final Object t)
}
public String toString(final Object t) {
return t.toString();
}
}
public abstract T getValue(final Object t);
public abstract T getValue(final Object t);
public abstract T parse(final String t);
public abstract T parse(final String t);
public abstract String getDescription();
public static class BooleanValue extends FlagValue<Boolean>
public abstract String getDescription();
public static class BooleanValue extends FlagValue<Boolean> {
@Override
public Boolean getValue(final Object t)
@Override
public Boolean getValue(final Object t) {
return (Boolean) t;
}
}
@Override
public Boolean parse(final String t)
{
switch (t.toLowerCase())
@Override
public Boolean parse(final String t) {
switch (t.toLowerCase()) {
case "1":
case "yes":
case "allow":
case "true":
case "allow":
case "true": {
return true;
}
case "0":
case "no":
case "deny":
case "false":
case "deny":
case "false": {
return false;
}
default:
}
default: {
return null;
}
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a boolean (true|false)";
}
}
public static class IntegerValue extends FlagValue<Integer>
}
public static class IntegerValue extends FlagValue<Integer> {
@Override
public Integer getValue(final Object t)
@Override
public Integer getValue(final Object t) {
return (Integer) t;
}
}
@Override
public Integer parse(final String t)
{
try
@Override
public Integer parse(final String t) {
try {
return Integer.parseInt(t);
}
catch (final IllegalArgumentException e)
return Integer.parseInt(t);
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a whole number";
}
}
public static class IntervalValue extends FlagValue<Integer[]>
}
public static class IntervalValue extends FlagValue<Integer[]> {
@Override
public String toString(final Object t)
@Override
public String toString(final Object t) {
final Integer[] value = ((Integer[]) t);
return value[0] + " " + value[1];
}
}
@Override
public Integer[] getValue(final Object t)
@Override
public Integer[] getValue(final Object t) {
return (Integer[]) t;
}
}
@Override
public Integer[] parse(final String t)
@Override
public Integer[] parse(final String t) {
int seconds;
int amount;
final String[] values = t.split(" ");
if (values.length < 2)
final String[] values = t.split(" ");
if (values.length < 2) {
seconds = 1;
try
seconds = 1;
try {
amount = Integer.parseInt(values[0]);
}
catch (final Exception e)
amount = Integer.parseInt(values[0]);
} catch (final Exception e) {
return null;
}
}
else
{
try
}
} else {
try {
amount = Integer.parseInt(values[0]);
seconds = Integer.parseInt(values[1]);
}
catch (final Exception e)
seconds = Integer.parseInt(values[1]);
} catch (final Exception e) {
return null;
}
}
return new Integer[] { amount, seconds };
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Value(s) must be numeric. /plot set flag <flag> <interval> [amount]";
}
}
public static class UnsignedIntegerValue extends FlagValue<Integer>
}
public static class UnsignedIntegerValue extends FlagValue<Integer> {
@Override
public Integer getValue(final Object t)
@Override
public Integer getValue(final Object t) {
return (Integer) t;
}
}
@Override
public Integer parse(final String t)
{
try
@Override
public Integer parse(final String t) {
try {
final int value = Integer.parseInt(t);
final int value = Integer.parseInt(t);
if (value < 0) {
return null;
}
return value;
}
catch (final IllegalArgumentException e)
return value;
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a positive whole number (includes 0)";
}
}
public static class DoubleValue extends FlagValue<Double>
}
public static class DoubleValue extends FlagValue<Double> {
@Override
public Double getValue(final Object t)
@Override
public Double getValue(final Object t) {
return (Double) t;
}
}
@Override
public Double parse(final String t)
{
try
@Override
public Double parse(final String t) {
try {
return Double.parseDouble(t);
}
catch (final IllegalArgumentException e)
return Double.parseDouble(t);
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a number (negative decimals are allowed)";
}
}
public static class LongValue extends FlagValue<Long>
}
public static class LongValue extends FlagValue<Long> {
@Override
public Long getValue(final Object t)
@Override
public Long getValue(final Object t) {
return (Long) t;
}
}
@Override
public Long parse(final String t)
{
try
@Override
public Long parse(final String t) {
try {
return Long.parseLong(t);
}
catch (final IllegalArgumentException e)
return Long.parseLong(t);
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a whole number (large numbers allowed)";
}
}
public static class UnsignedLongValue extends FlagValue<Long>
}
public static class UnsignedLongValue extends FlagValue<Long> {
@Override
public Long getValue(final Object t)
@Override
public Long getValue(final Object t) {
return (Long) t;
}
}
@Override
public Long parse(final String t)
{
try
@Override
public Long parse(final String t) {
try {
final long value = Long.parseLong(t);
final long value = Long.parseLong(t);
if (value < 0) {
return null;
}
return value;
}
catch (final IllegalArgumentException e)
return value;
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a positive whole number (large numbers allowed)";
}
}
public static class UnsignedDoubleValue extends FlagValue<Double>
}
public static class UnsignedDoubleValue extends FlagValue<Double> {
@Override
public Double getValue(final Object t)
@Override
public Double getValue(final Object t) {
return (Double) t;
}
}
@Override
public Double parse(final String t)
{
try
@Override
public Double parse(final String t) {
try {
final double value = Double.parseDouble(t);
final double value = Double.parseDouble(t);
if (value < 0) {
return null;
}
return value;
}
catch (final IllegalArgumentException e)
return value;
} catch (final IllegalArgumentException e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a positive number (decimals allowed)";
}
}
public static class PlotBlockValue extends FlagValue<PlotBlock>
}
public static class PlotBlockValue extends FlagValue<PlotBlock> {
@Override
public PlotBlock getValue(final Object t)
@Override
public PlotBlock getValue(final Object t) {
return (PlotBlock) t;
}
}
@Override
public PlotBlock parse(final String t)
{
try
@Override
public PlotBlock parse(final String t) {
try {
final String[] split = t.split(":");
byte data;
if (split.length == 2)
{
if ("*".equals(split[1]))
byte data;
if (split.length == 2) {
if ("*".equals(split[1])) {
data = -1;
}
else
data = -1;
} else {
data = Byte.parseByte(split[1]);
}
}
else
}
} else {
data = -1;
}
final short id = Short.parseShort(split[0]);
return new PlotBlock(id, data);
}
catch (final Exception e)
return new PlotBlock(id, data);
} catch (final Exception e) {
return null;
}
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a number (negative decimals are allowed)";
}
}
public interface ListValue
}
public interface ListValue {
void add(final Object t, final String value);
void add(final Object t, final String value);
void remove(final Object t, final String value);
}
public static class PlotBlockListValue extends FlagValue<HashSet<PlotBlock>> implements ListValue
}
public static class PlotBlockListValue extends FlagValue<HashSet<PlotBlock>> implements ListValue {
@SuppressWarnings("unchecked")
@Override
public String toString(final Object t)
@Override
public String toString(final Object t) {
return StringMan.join((HashSet<PlotBlock>) t, ",");
}
}
@SuppressWarnings("unchecked")
@Override
public HashSet<PlotBlock> getValue(final Object t)
@Override
public HashSet<PlotBlock> getValue(final Object t) {
return (HashSet<PlotBlock>) t;
}
}
@Override
public HashSet<PlotBlock> parse(final String t)
@Override
public HashSet<PlotBlock> parse(final String t) {
final HashSet<PlotBlock> list = new HashSet<PlotBlock>();
for (final String item : t.split(","))
final HashSet<PlotBlock> list = new HashSet<PlotBlock>();
for (final String item : t.split(",")) {
final String[] split = item.split(":");
byte data;
if (split.length == 2)
{
if ("*".equals(split[1]))
byte data;
if (split.length == 2) {
if ("*".equals(split[1])) {
data = -1;
}
else
data = -1;
} else {
data = Byte.parseByte(split[1]);
}
}
else
}
} else {
data = -1;
}
@ -412,230 +326,172 @@ public abstract class FlagValue<T>
list.add(block);
}
return list;
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a block list";
}
}
@Override
public void add(final Object t, final String value)
{
try
@Override
public void add(final Object t, final String value) {
try {
((HashSet<PlotBlock>) t).addAll(parse(value));
}
catch (final Exception e)
((HashSet<PlotBlock>) t).addAll(parse(value));
} catch (final Exception e) {}
}
}
@Override
public void remove(final Object t, final String value)
{
try
{
for (final PlotBlock item : parse(value))
@Override
public void remove(final Object t, final String value) {
try {
for (final PlotBlock item : parse(value)) {
((HashSet<PlotBlock>) t).remove(item);
}
}
catch (final Exception e)
}
} catch (final Exception e) {}
}
}
public static class IntegerListValue extends FlagValue<List<Integer>> implements ListValue
}
public static class IntegerListValue extends FlagValue<List<Integer>> implements ListValue {
@SuppressWarnings("unchecked")
@Override
public String toString(final Object t)
@Override
public String toString(final Object t) {
return StringMan.join((List<Integer>) t, ",");
}
}
@SuppressWarnings("unchecked")
@Override
public List<Integer> getValue(final Object t)
@Override
public List<Integer> getValue(final Object t) {
return (List<Integer>) t;
}
}
@Override
public List<Integer> parse(final String t)
@Override
public List<Integer> parse(final String t) {
final String[] split = (t.split(","));
final ArrayList<Integer> numbers = new ArrayList<Integer>();
for (final String element : split)
final ArrayList<Integer> numbers = new ArrayList<Integer>();
for (final String element : split) {
numbers.add(Integer.parseInt(element));
}
return numbers;
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a integer list";
}
}
@Override
public void add(final Object t, final String value)
{
try
@Override
public void add(final Object t, final String value) {
try {
((List<Integer>) t).addAll(parse(value));
}
catch (final Exception e)
((List<Integer>) t).addAll(parse(value));
} catch (final Exception e) {}
}
}
@Override
public void remove(final Object t, final String value)
{
try
{
for (final Integer item : parse(value))
@Override
public void remove(final Object t, final String value) {
try {
for (final Integer item : parse(value)) {
((List<Integer>) t).remove(item);
}
}
catch (final Exception e)
}
} catch (final Exception e) {}
}
}
}
@SuppressWarnings("ALL")
public static class StringListValue extends FlagValue<List<String>> implements ListValue
{
@SuppressWarnings("ALL")
public static class StringListValue extends FlagValue<List<String>> implements ListValue {
@Override
public String toString(final Object t)
@Override
public String toString(final Object t) {
return StringMan.join((List<String>) t, ",");
}
}
@Override
public List<String> getValue(final Object t)
@Override
public List<String> getValue(final Object t) {
return (List<String>) t;
}
}
@Override
public List<String> parse(final String t)
@Override
public List<String> parse(final String t) {
return Arrays.asList(t.split(","));
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a string list";
}
}
@Override
public void add(final Object t, final String value)
{
try
@Override
public void add(final Object t, final String value) {
try {
((List<String>) t).addAll(parse(value));
}
catch (final Exception ignored)
((List<String>) t).addAll(parse(value));
} catch (final Exception ignored) {}
}
}
@Override
public void remove(final Object t, final String value)
{
try
{
for (final String item : parse(value))
@Override
public void remove(final Object t, final String value) {
try {
for (final String item : parse(value)) {
((List<String>) t).remove(item);
}
}
catch (final Exception e)
}
} catch (final Exception e) {}
}
}
public static class DoubleListValue extends FlagValue<List<Double>> implements ListValue
}
public static class DoubleListValue extends FlagValue<List<Double>> implements ListValue {
@SuppressWarnings("unchecked")
@Override
public String toString(final Object t)
@Override
public String toString(final Object t) {
return StringMan.join((List<Double>) t, ",");
}
}
@SuppressWarnings("unchecked")
@Override
public List<Double> getValue(final Object t)
@Override
public List<Double> getValue(final Object t) {
return (List<Double>) t;
}
}
@Override
public List<Double> parse(final String t)
@Override
public List<Double> parse(final String t) {
final String[] split = (t.split(","));
final ArrayList<Double> numbers = new ArrayList<Double>();
for (final String element : split)
final ArrayList<Double> numbers = new ArrayList<Double>();
for (final String element : split) {
numbers.add(Double.parseDouble(element));
}
return numbers;
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be a integer list";
}
}
@Override
public void add(final Object t, final String value)
{
try
@Override
public void add(final Object t, final String value) {
try {
((List<Double>) t).addAll(parse(value));
}
catch (final Exception e)
((List<Double>) t).addAll(parse(value));
} catch (final Exception e) {}
}
}
@Override
public void remove(final Object t, final String value)
{
try
{
for (final Double item : parse(value))
@Override
public void remove(final Object t, final String value) {
try {
for (final Double item : parse(value)) {
((List<Double>) t).remove(item);
}
}
catch (final Exception e)
}
} catch (final Exception e) {}
}
}
public static class StringValue extends FlagValue<String>
}
public static class StringValue extends FlagValue<String> {
@Override
public String parse(final String s)
@Override
public String parse(final String s) {
return s;
}
}
@Override
public String getDescription()
@Override
public String getDescription() {
return "Flag value must be alphanumeric. Some special characters are allowed.";
}
}
@Override
public String getValue(final Object t)
@Override
public String getValue(final Object t) {
return t.toString();
}