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