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 }