001 /* OpenMBeanParameterInfoSupport.java -- Open typed info about a parameter.
002 Copyright (C) 2006, 2007 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package javax.management.openmbean;
039
040 import java.util.Collections;
041 import java.util.HashSet;
042 import java.util.Set;
043
044 import javax.management.MBeanParameterInfo;
045
046 /**
047 * Describes the parameters of a constructor or operation associated
048 * with an open management bean.
049 *
050 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
051 * @since 1.5
052 */
053 public class OpenMBeanParameterInfoSupport
054 extends MBeanParameterInfo
055 implements OpenMBeanParameterInfo
056 {
057
058 /**
059 * Compatible with JDK 1.5
060 */
061 private static final long serialVersionUID = -7235016873758443122L;
062
063 /**
064 * The open type of the parameter.
065 */
066 private OpenType<?> openType;
067
068 /**
069 * The default value of the parameter (may be <code>null</code>).
070 */
071 private Object defaultValue;
072
073 /**
074 * The possible legal values of the parameter (may be <code>null</code>).
075 */
076 private Set<?> legalValues;
077
078 /**
079 * The minimum value of the parameter (may be <code>null</code>).
080 */
081 private Comparable<Object> minValue;
082
083 /**
084 * The maximum value of the parameter (may be <code>null</code>).
085 */
086 private Comparable<Object> maxValue;
087
088 /**
089 * The hash code of this instance.
090 */
091 private transient Integer hashCode;
092
093 /**
094 * The <code>toString()</code> result of this instance.
095 */
096 private transient String string;
097
098 /**
099 * Constructs a new {@link OpenMBeanParameterInfo} using the specified
100 * name, description and open type. None of these values may be
101 * <code>null</code> and the name and description may not be equal
102 * to the empty string.
103 *
104 * @param name the name of the parameter.
105 * @param desc a description of the parameter.
106 * @param type the open type of the parameter.
107 * @throws IllegalArgumentException if the name, description or
108 * open type are <code>null</code>
109 * or the name or description are
110 * the empty string.
111 */
112 public OpenMBeanParameterInfoSupport(String name, String desc, OpenType<?> type)
113 {
114 super(name, type == null ? null : type.getClassName(), desc);
115 if (name == null)
116 throw new IllegalArgumentException("The name may not be null.");
117 if (desc == null)
118 throw new IllegalArgumentException("The description may not be null.");
119 if (type == null)
120 throw new IllegalArgumentException("The type may not be null.");
121 if (name.length() == 0)
122 throw new IllegalArgumentException("The name may not be the empty string.");
123 if (desc.length() == 0)
124 throw new IllegalArgumentException("The description may not be the " +
125 "empty string.");
126 openType = type;
127 }
128
129 /**
130 * Constructs a new {@link OpenMBeanParameterInfo} using the
131 * specified name, description, open type and default value. The
132 * name, description and open type cannot be <code>null</code> and
133 * the name and description may not be equal to the empty string.
134 * The default value may be <code>null</code>. If non-null, it must
135 * be a valid value of the given open type. Default values are not
136 * applicable to the open types, {@link ArrayType} and {@link
137 * TabularType}.
138 *
139 * @param name the name of the parameter.
140 * @param desc a description of the parameter.
141 * @param type the open type of the parameter.
142 * @param defaultValue the default value of the parameter.
143 * @throws IllegalArgumentException if the name, description or
144 * open type are <code>null</code>
145 * or the name or description are
146 * the empty string.
147 * @throws OpenDataException if <code>defaultValue<code> is non-null
148 * and is either not a value of the given
149 * open type or the open type is an instance
150 * of {@link ArrayType} or {@link TabularType}.
151 */
152 public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
153 T defaultValue)
154 throws OpenDataException
155 {
156 this(name, desc, type, defaultValue, null);
157 }
158
159 /**
160 * <p>
161 * Constructs a new {@link OpenMBeanParameterInfo} using the
162 * specified name, description, open type, default, maximum and
163 * minimum values. The name, description and open type cannot be
164 * <code>null</code> and the name and description may not be equal
165 * to the empty string. The default, maximum and minimum values may
166 * be <code>null</code>. The following conditions apply when the
167 * parameters mentioned are non-null:
168 * </p>
169 * <ul>
170 * <li>The values must be valid values for the given open type.</li>
171 * <li>Default values are not applicable to the open types, {@link
172 * ArrayType} and {@link TabularType}.</li>
173 * <li>The minimum value must be smaller than or equal to the maximum value
174 * (literally, <code>minValue.compareTo(maxValue) <= 0</code>.</li>
175 * <li>The minimum value must be smaller than or equal to the default value
176 * (literally, <code>minValue.compareTo(defaultValue) <= 0</code>.</li>
177 * <li>The default value must be smaller than or equal to the maximum value
178 * (literally, <code>defaultValue.compareTo(maxValue) <= 0</code>.</li>
179 * </ul>
180 *
181 * @param name the name of the parameter.
182 * @param desc a description of the parameter.
183 * @param type the open type of the parameter.
184 * @param defaultValue the default value of the parameter, or <code>null</code>.
185 * @param minimumValue the minimum value of the parameter, or <code>null</code>.
186 * @param maximumValue the maximum value of the parameter, or <code>null</code>.
187 * @throws IllegalArgumentException if the name, description or
188 * open type are <code>null</code>
189 * or the name or description are
190 * the empty string.
191 * @throws OpenDataException if any condition in the list above is broken.
192 */
193 public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
194 T defaultValue, Comparable<T> minimumValue,
195 Comparable<T> maximumValue)
196 throws OpenDataException
197 {
198 this(name, desc, type);
199 if (defaultValue != null && !(type.isValue(defaultValue)))
200 throw new OpenDataException("The default value is not a member of the " +
201 "open type given.");
202 if (minimumValue != null && !(type.isValue(minimumValue)))
203 throw new OpenDataException("The minimum value is not a member of the " +
204 "open type given.");
205 if (maximumValue != null && !(type.isValue(maximumValue)))
206 throw new OpenDataException("The maximum value is not a member of the " +
207 "open type given.");
208 if (defaultValue != null && (type instanceof ArrayType ||
209 type instanceof TabularType))
210 throw new OpenDataException("Default values are not applicable for " +
211 "array or tabular types.");
212 if (minValue != null && maxValue != null
213 && minValue.compareTo(maxValue) > 0)
214 throw new OpenDataException("The minimum value is greater than the " +
215 "maximum.");
216 if (minValue != null && defaultValue != null
217 && minValue.compareTo(defaultValue) > 0)
218 throw new OpenDataException("The minimum value is greater than the " +
219 "default.");
220 if (defaultValue != null && maxValue != null
221 && maxValue.compareTo(defaultValue) < 0)
222 throw new OpenDataException("The default value is greater than the " +
223 "maximum.");
224
225 this.defaultValue = defaultValue;
226 minValue = (Comparable<Object>) minimumValue;
227 maxValue = (Comparable<Object>) maximumValue;
228 }
229
230 /**
231 * <p>
232 * Constructs a new {@link OpenMBeanParameterInfo} using the
233 * specified name, description, open type, default value and
234 * set of legal values. The name, description and open type cannot be
235 * <code>null</code> and the name and description may not be equal
236 * to the empty string. The default, maximum and minimum values may
237 * be <code>null</code>. The following conditions apply when the
238 * parameters mentioned are non-null:
239 * </p>
240 * <ul>
241 * <li>The default value and each of the legal values must be a valid
242 * value for the given open type.</li>
243 * <li>Default and legal values are not applicable to the open types, {@link
244 * ArrayType} and {@link TabularType}.</li>
245 * <li>The default value is not in the set of legal values.</li>
246 * </ul>
247 * <p>
248 * The legal values are copied from the array into a unmodifiable set,
249 * so future modifications to the array have no effect.
250 * </p>
251 *
252 * @param name the name of the parameter.
253 * @param desc a description of the parameter.
254 * @param type the open type of the parameter.
255 * @param defaultValue the default value of the parameter, or <code>null</code>.
256 * @param legalValues the legal values of the parameter. May be
257 * <code>null</code> or an empty array.
258 * @throws IllegalArgumentException if the name, description or
259 * open type are <code>null</code>
260 * or the name or description are
261 * the empty string.
262 * @throws OpenDataException if any condition in the list above is broken.
263 */
264 public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
265 T defaultValue, T[] legalValues)
266 throws OpenDataException
267 {
268 this(name, desc, type);
269 if (defaultValue != null && !(type.isValue(defaultValue)))
270 throw new OpenDataException("The default value is not a member of the " +
271 "open type given.");
272 if (defaultValue != null && (type instanceof ArrayType ||
273 type instanceof TabularType))
274 throw new OpenDataException("Default values are not applicable for " +
275 "array or tabular types.");
276 if (legalValues != null && (type instanceof ArrayType ||
277 type instanceof TabularType))
278 throw new OpenDataException("Legal values are not applicable for " +
279 "array or tabular types.");
280 if (legalValues != null && legalValues.length > 0)
281 {
282 Set lv = new HashSet(legalValues.length);
283 for (int a = 0; a < legalValues.length; ++a)
284 {
285 if (legalValues[a] != null &&
286 !(type.isValue(legalValues[a])))
287 throw new OpenDataException("The legal value, "
288 + legalValues[a] +
289 "is not a member of the " +
290 "open type given.");
291 lv.add(legalValues[a]);
292 }
293 if (defaultValue != null && !(lv.contains(defaultValue)))
294 throw new OpenDataException("The default value is not in the set " +
295 "of legal values.");
296 this.legalValues = Collections.unmodifiableSet(lv);
297 }
298 this.defaultValue = defaultValue;
299 }
300
301 /**
302 * Compares this parameter with the supplied object. This returns
303 * true iff the object is an instance of {@link OpenMBeanParameterInfo}
304 * with an equal name and open type and the same default, minimum,
305 * maximum and legal values.
306 *
307 * @param obj the object to compare.
308 * @return true if the object is a {@link OpenMBeanParameterInfo}
309 * instance,
310 * <code>name.equals(object.getName())</code>,
311 * <code>openType.equals(object.getOpenType())</code>,
312 * <code>defaultValue.equals(object.getDefaultValue())</code>,
313 * <code>minValue.equals(object.getMinValue())</code>,
314 * <code>maxValue.equals(object.getMaxValue())</code>,
315 * and <code>legalValues.equals(object.getLegalValues())</code>.
316 */
317 public boolean equals(Object obj)
318 {
319 if (!(obj instanceof OpenMBeanParameterInfo))
320 return false;
321 OpenMBeanParameterInfo o = (OpenMBeanParameterInfo) obj;
322 return getName().equals(o.getName()) &&
323 openType.equals(o.getOpenType()) &&
324 (defaultValue == null ? o.getDefaultValue() == null :
325 defaultValue.equals(o.getDefaultValue())) &&
326 (minValue == null ? o.getMinValue() == null :
327 minValue.equals(o.getMinValue())) &&
328 (maxValue == null ? o.getMaxValue() == null :
329 maxValue.equals(o.getMaxValue())) &&
330 (legalValues == null ? o.getLegalValues() == null :
331 legalValues.equals(o.getLegalValues()));
332 }
333
334 /**
335 * Returns the default value of this parameter, or <code>null</code>
336 * if there is no default value.
337 *
338 * @return the default value of the parameter, or <code>null</code>
339 * if there is no default.
340 */
341 public Object getDefaultValue()
342 {
343 return defaultValue;
344 }
345
346 /**
347 * Returns a {@link java.util.Set} enumerating the legal values
348 * of this parameter, or <code>null</code> if no such limited
349 * set exists for this parameter.
350 *
351 * @return a set of legal values, or <code>null</code> if no such
352 * set exists.
353 */
354 public Set<?> getLegalValues()
355 {
356 return legalValues;
357 }
358
359 /**
360 * Returns the maximum value of this parameter, or <code>null</code>
361 * if there is no maximum.
362 *
363 * @return the maximum value, or <code>null</code> if none exists.
364 */
365 public Comparable<?> getMaxValue()
366 {
367 return maxValue;
368 }
369
370 /**
371 * Returns the minimum value of this parameter, or <code>null</code>
372 * if there is no minimum.
373 *
374 * @return the minimum value, or <code>null</code> if none exists.
375 */
376 public Comparable<?> getMinValue()
377 {
378 return minValue;
379 }
380
381 /**
382 * Returns the open type instance which represents the type of this
383 * parameter.
384 *
385 * @return the open type of this parameter.
386 */
387 public OpenType<?> getOpenType()
388 {
389 return openType;
390 }
391
392 /**
393 * Returns true if this parameter has a default value
394 * (i.e. the value is non-null).
395 *
396 * @return true if this parameter has a default.
397 */
398 public boolean hasDefaultValue()
399 {
400 return defaultValue != null;
401 }
402
403 /**
404 * <p>
405 * Returns the hashcode of the parameter information as the sum of
406 * the hashcodes of the name, open type, default value, maximum
407 * value, minimum value and the set of legal values.
408 * </p>
409 * <p>
410 * As instances of this class are immutable, the hash code
411 * is computed just once for each instance and reused
412 * throughout its life.
413 * </p>
414 *
415 * @return the hashcode of the parameter information.
416 */
417 public int hashCode()
418 {
419 if (hashCode == null)
420 hashCode = Integer.valueOf(getName().hashCode() +
421 openType.hashCode() +
422 (defaultValue == null ? 0 :
423 defaultValue.hashCode()) +
424 (minValue == null ? 0 :
425 minValue.hashCode()) +
426 (maxValue == null ? 0 :
427 maxValue.hashCode()) +
428 (legalValues == null ? 0 :
429 legalValues.hashCode()));
430 return hashCode.intValue();
431 }
432
433 /**
434 * Returns true if there is a set of legal values for this
435 * parameter (i.e. the value is non-null).
436 *
437 * @return true if a set of legal values exists for this
438 * parameter.
439 */
440 public boolean hasLegalValues()
441 {
442 return legalValues != null;
443 }
444
445 /**
446 * Returns true if there is a maximum value for this parameter
447 * (i.e. the value is non-null).
448 *
449 * @return true if a maximum value exists for this parameter.
450 */
451 public boolean hasMaxValue()
452 {
453 return maxValue != null;
454 }
455
456 /**
457 * Returns true if there is a minimum value for this parameter.
458 * (i.e. the value is non-null).
459 *
460 * @return true if a minimum value exists for this parameter.
461 */
462 public boolean hasMinValue()
463 {
464 return minValue != null;
465 }
466
467 /**
468 * Returns true if the specified object is a valid value for
469 * this parameter.
470 *
471 * @param obj the object to test.
472 * @return true if <code>obj</code> is a valid value for this
473 * parameter.
474 */
475 public boolean isValue(Object obj)
476 {
477 return openType.isValue(obj);
478 }
479
480 /**
481 * <p>
482 * Returns a textual representation of this instance. This
483 * is constructed using the class name
484 * (<code>javax.management.openmbean.OpenMBeanParameterInfo</code>)
485 * along with the name, open type, default, minimum, maximum
486 * and legal values of the parameter.
487 * </p>
488 * <p>
489 * As instances of this class are immutable, the return value
490 * is computed just once for each instance and reused
491 * throughout its life.
492 * </p>
493 *
494 * @return a @link{java.lang.String} instance representing
495 * the instance in textual form.
496 */
497 public String toString()
498 {
499 if (string == null)
500 string = getClass().getName()
501 + "[name=" + getName()
502 + ",openType=" + openType
503 + ",defaultValue=" + defaultValue
504 + ",minValue=" + minValue
505 + ",maxValue=" + maxValue
506 + ",legalValues=" + legalValues
507 + "]";
508 return string;
509 }
510
511 }