    001/**
    002 * This software is provided under the terms of the Minecraft Forge Public
    003 * License v1.0.
    004 */
    005
    006package net.minecraftforge.common;
    007
    008import java.util.ArrayList;
    009
    010import net.minecraftforge.common.Property.Type;
    011
    012public class Property
    013{
    014    public enum Type
    015    {
    016        STRING,
    017        INTEGER,
    018        BOOLEAN,
    019        DOUBLE;
    020
    021        private static Type[] values = {STRING, INTEGER, BOOLEAN, DOUBLE};
    022
    023        public static Type tryParse(char id)
    024        {
    025            for (int x = 0; x < values.length; x++)
    026            {
    027                if (values[x].getID() == id)
    028                {
    029                    return values[x];
    030                }
    031            }
    032
    033            return STRING;
    034        }
    035
    036        public char getID()
    037        {
    038            return name().charAt(0);
    039        }
    040    }
    041
    042    private String name;
    043    private String value;
    044    public String comment;
    045    private String[] values;
    046
    047    private final boolean wasRead;
    048    private final boolean isList;
    049    private final Type type;
    050    private boolean changed = false;
    051
    052    public Property()
    053    {
    054        wasRead = false;
    055        type    = null;
    056        isList  = false;
    057    }
    058
    059    public Property(String name, String value, Type type)
    060    {
    061        this(name, value, type, false);
    062    }
    063
    064    Property(String name, String value, Type type, boolean read)
    065    {
    066        setName(name);
    067        this.value = value;
    068        this.type  = type;
    069        wasRead    = read;
    070        isList     = false;
    071    }
    072
    073    public Property(String name, String[] values, Type type)
    074    {
    075        this(name, values, type, false);
    076    }
    077
    078    Property(String name, String[] values, Type type, boolean read)
    079    {
    080        setName(name);
    081        this.type   = type;
    082        this.values = values;
    083        wasRead     = read;
    084        isList      = true;
    085    }
    086
    087    /**
    088     * Returns the value in this property as it's raw string.
    089     *
    090     * @return current value
    091     */
    092    public String getString()
    093    {
    094        return value;
    095    }
    096
    097    /**
    098     * Returns the value in this property as an integer,
    099     * if the value is not a valid integer, it will return -1.
    100     *
    101     * @return The value
    102     */
    103    public int getInt()
    104    {
    105        return getInt(-1);
    106    }
    107
    108    /**
    109     * Returns the value in this property as an integer,
    110     * if the value is not a valid integer, it will return the
    111     * provided default.
    112     *
    113     * @param _default The default to provide if the current value is not a valid integer
    114     * @return The value
    115     */
    116    public int getInt(int _default)
    117    {
    118        try
    119        {
    120            return Integer.parseInt(value);
    121        }
    122        catch (NumberFormatException e)
    123        {
    124            return _default;
    125        }
    126    }
    127
    128    /**
    129     * Checks if the current value stored in this property can be converted to an integer.
    130     * @return True if the type of the Property is an Integer
    131     */
    132    public boolean isIntValue()
    133    {
    134        try
    135        {
    136            Integer.parseInt(value);
    137            return true;
    138        }
    139        catch (NumberFormatException e)
    140        {
    141            return false;
    142        }
    143    }
    144
    145    /**
    146     * Returns the value in this property as a boolean,
    147     * if the value is not a valid boolean, it will return the
    148     * provided default.
    149     *
    150     * @param _default The default to provide
    151     * @return The value as a boolean, or the default
    152     */
    153    public boolean getBoolean(boolean _default)
    154    {
    155        if (isBooleanValue())
    156        {
    157            return Boolean.parseBoolean(value);
    158        }
    159        else
    160        {
    161            return _default;
    162        }
    163    }
    164
    165    /**
    166     * Checks if the current value held by this property is a valid boolean value.
    167     * @return True if it is a boolean value
    168     */
    169    public boolean isBooleanValue()
    170    {
    171        return ("true".equals(value.toLowerCase()) || "false".equals(value.toLowerCase()));
    172    }
    173
    174    /**
    175     * Checks if the current value held by this property is a valid double value.
    176     * @return True if the value can be converted to an double
    177     */
    178    public boolean isDoubleValue()
    179    {
    180        try
    181        {
    182            Double.parseDouble(value);
    183            return true;
    184        }
    185        catch (NumberFormatException e)
    186        {
    187            return false;
    188        }
    189    }
    190
    191    /**
    192     * Returns the value in this property as a double,
    193     * if the value is not a valid double, it will return the
    194     * provided default.
    195     *
    196     * @param _default The default to provide if the current value is not a valid double
    197     * @return The value
    198     */
    199    public double getDouble(double _default)
    200    {
    201        try
    202        {
    203            return Double.parseDouble(value);
    204        }
    205        catch (NumberFormatException e)
    206        {
    207            return _default;
    208        }
    209    }
    210
    211    public String[] getStringList()
    212    {
    213        return values;
    214    }
    215
    216    /**
    217     * Returns the integer value of all values that can
    218     * be parsed in the list.
    219     *
    220     * @return Array of length 0 if none of the values could be parsed.
    221     */
    222    public int[] getIntList()
    223    {
    224        ArrayList<Integer> nums = new ArrayList<Integer>();
    225
    226        for (String value : values)
    227        {
    228            try
    229            {
    230                nums.add(Integer.parseInt(value));
    231            }
    232            catch (NumberFormatException e){}
    233        }
    234
    235        int[] primitives = new int[nums.size()];
    236
    237        for (int i = 0; i < nums.size(); i++)
    238        {
    239            primitives[i] = nums.get(i);
    240        }
    241
    242        return primitives;
    243    }
    244
    245    /**
    246     * Checks if all of the current values stored in this property can be converted to an integer.
    247     * @return True if the type of the Property is an Integer List
    248     */
    249    public boolean isIntList()
    250    {
    251        for (String value : values)
    252        {
    253            try
    254            {
    255                Integer.parseInt(value);
    256            }
    257            catch (NumberFormatException e)
    258            {
    259                return false;
    260            }
    261        }
    262        return true;
    263    }
    264
    265    /**
    266     * Returns the boolean value of all values that can
    267     * be parsed in the list.
    268     *
    269     * @return Array of length 0 if none of the values could be parsed.
    270     */
    271    public boolean[] getBooleanList()
    272    {
    273        ArrayList<Boolean> tmp = new ArrayList<Boolean>();
    274        for (String value : values)
    275        {
    276            try
    277            {
    278                tmp.add(Boolean.parseBoolean(value));
    279            }
    280            catch (NumberFormatException e){}
    281        }
    282
    283        boolean[] primitives = new boolean[tmp.size()];
    284
    285        for (int i = 0; i < tmp.size(); i++)
    286        {
    287            primitives[i] = tmp.get(i);
    288        }
    289
    290        return primitives;
    291    }
    292
    293    /**
    294     * Checks if all of current values stored in this property can be converted to a boolean.
    295     * @return True if it is a boolean value
    296     */
    297    public boolean isBooleanList()
    298    {
    299        for (String value : values)
    300        {
    301            if (!"true".equalsIgnoreCase(value) && !"false".equalsIgnoreCase(value))
    302            {
    303                return false;
    304            }
    305        }
    306
    307        return true;
    308    }
    309
    310    /**
    311     * Returns the double value of all values that can
    312     * be parsed in the list.
    313     *
    314     * @return Array of length 0 if none of the values could be parsed.
    315     */
    316    public double[] getDoubleList()
    317    {
    318        ArrayList<Double> tmp = new ArrayList<Double>();
    319        for (String value : values)
    320        {
    321            try
    322            {
    323                tmp.add(Double.parseDouble(value));
    324            }
    325            catch (NumberFormatException e) {}
    326        }
    327
    328        double[] primitives = new double[tmp.size()];
    329
    330        for (int i = 0; i < tmp.size(); i++)
    331        {
    332            primitives[i] = tmp.get(i);
    333        }
    334
    335        return primitives;
    336    }
    337
    338    /**
    339     * Checks if all of the current values stored in this property can be converted to a double.
    340     * @return True if the type of the Property is a double List
    341     */
    342    public boolean isDoubleList()
    343    {
    344        for (String value : values)
    345        {
    346            try
    347            {
    348                Double.parseDouble(value);
    349            }
    350            catch (NumberFormatException e)
    351            {
    352                return false;
    353            }
    354        }
    355
    356        return true;
    357    }
    358
    359    public String getName()
    360    {
    361        return name;
    362    }
    363
    364    public void setName(String name)
    365    {
    366        this.name = name;
    367    }
    368
    369    /**
    370     * Determines if this config value was just created, or if it was read from the config file.
    371     * This is useful for mods who auto-assign there blocks to determine if the ID returned is
    372     * a configured one, or a automatically generated one.
    373     *
    374     * @return True if this property was loaded from the config file with a value
    375     */
    376    public boolean wasRead()
    377    {
    378        return wasRead;
    379    }
    380
    381    public Type getType()
    382    {
    383        return type;
    384    }
    385
    386    public boolean isList()
    387    {
    388        return isList;
    389    }
    390
    391    public boolean hasChanged(){ return changed; }
    392    void resetChangedState(){ changed = false; }
    393
    394    public void set(String value)
    395    {
    396        this.value = value;
    397        changed = true;
    398    }
    399
    400    public void set(String[] values)
    401    {
    402        this.values = values;
    403        changed = true;
    404    }
    405
    406    public void set(int     value){ set(Integer.toString(value)); }
    407    public void set(boolean value){ set(Boolean.toString(value)); }
    408    public void set(double  value){ set(Double.toString(value));  }
    409}