| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* OpenMBeanParameterInfoSupport.java -- Open typed info about a parameter. 2: Copyright (C) 2006, 2007 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: package javax.management.openmbean; 39: 40: import java.util.Collections; 41: import java.util.HashSet; 42: import java.util.Set; 43: 44: import javax.management.MBeanParameterInfo; 45: 46: /** 47: * Describes the parameters of a constructor or operation associated 48: * with an open management bean. 49: * 50: * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 51: * @since 1.5 52: */ 53: public class OpenMBeanParameterInfoSupport 54: extends MBeanParameterInfo 55: implements OpenMBeanParameterInfo 56: { 57: 58: /** 59: * Compatible with JDK 1.5 60: */ 61: private static final long serialVersionUID = -7235016873758443122L; 62: 63: /** 64: * The open type of the parameter. 65: */ 66: private OpenType<?> openType; 67: 68: /** 69: * The default value of the parameter (may be <code>null</code>). 70: */ 71: private Object defaultValue; 72: 73: /** 74: * The possible legal values of the parameter (may be <code>null</code>). 75: */ 76: private Set<?> legalValues; 77: 78: /** 79: * The minimum value of the parameter (may be <code>null</code>). 80: */ 81: private Comparable<Object> minValue; 82: 83: /** 84: * The maximum value of the parameter (may be <code>null</code>). 85: */ 86: private Comparable<Object> maxValue; 87: 88: /** 89: * The hash code of this instance. 90: */ 91: private transient Integer hashCode; 92: 93: /** 94: * The <code>toString()</code> result of this instance. 95: */ 96: private transient String string; 97: 98: /** 99: * 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: }
| GNU Classpath (0.95) |