| Frames | No Frames |
1: /* OpenMBeanAttributeInfoSupport.java -- Open typed info about an attribute. 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.MBeanAttributeInfo; 45: 46: /** 47: * Describes an attribute of an open management bean. 48: * 49: * @author Andrew John Hughes (gnu_andrew@member.fsf.org) 50: * @since 1.5 51: */ 52: public class OpenMBeanAttributeInfoSupport 53: extends MBeanAttributeInfo 54: implements OpenMBeanAttributeInfo 55: { 56: 57: /** 58: * Compatible with JDK 1.5 59: */ 60: private static final long serialVersionUID = -4867215622149721849L; 61: 62: /** 63: * The open type of the attribute. 64: */ 65: private OpenType<?> openType; 66: 67: /** 68: * The default value of the attribute (may be <code>null</code>). 69: */ 70: private Object defaultValue; 71: 72: /** 73: * The possible legal values of the attribute (may be <code>null</code>). 74: */ 75: private Set<?> legalValues; 76: 77: /** 78: * The minimum value of the attribute (may be <code>null</code>). 79: */ 80: private Comparable<?> minValue; 81: 82: /** 83: * The maximum value of the attribute (may be <code>null</code>). 84: */ 85: private Comparable<?> maxValue; 86: 87: /** 88: * The hash code of this instance. 89: */ 90: private transient Integer hashCode; 91: 92: /** 93: * The <code>toString()</code> result of this instance. 94: */ 95: private transient String string; 96: 97: /** 98: * Constructs a new {@link OpenMBeanAttributeInfo} using the 99: * specified name, description, open type and access properties. 100: * The name, description and open type may not be <code>null</code> 101: * and the name and description may not be equal to the empty 102: * string. 103: * 104: * @param name the name of the attribute. 105: * @param desc a description of the attribute. 106: * @param type the open type of the attribute. 107: * @param isReadable true if the attribute's value can be read. 108: * @param isWritable true if the attribute's value can be changed. 109: * @param isIs true if the attribute uses an accessor of the form isXXX. 110: * @throws IllegalArgumentException if the name, description or 111: * open type are <code>null</code> 112: * or the name or description are 113: * the empty string. 114: */ 115: public OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<?> type, 116: boolean isReadable, boolean isWritable, 117: boolean isIs) 118: { 119: super(name, type == null ? null : type.getClassName(), desc, isReadable, 120: isWritable, isIs); 121: if (name == null) 122: throw new IllegalArgumentException("The name may not be null."); 123: if (desc == null) 124: throw new IllegalArgumentException("The description may not be null."); 125: if (type == null) 126: throw new IllegalArgumentException("The type may not be null."); 127: if (name.length() == 0) 128: throw new IllegalArgumentException("The name may not be the empty string."); 129: if (desc.length() == 0) 130: throw new IllegalArgumentException("The description may not be the " + 131: "empty string."); 132: } 133: 134: /** 135: * Constructs a new {@link OpenMBeanAttributeInfo} using the 136: * specified name, description, open type and default value. The 137: * name, description and open type cannot be <code>null</code> and 138: * the name and description may not be equal to the empty string. 139: * The default value may be <code>null</code>. If non-null, it must 140: * be a valid value of the given open type. Default values are not 141: * applicable to the open types, {@link ArrayType} and {@link 142: * TabularType}. 143: * 144: * @param name the name of the attribute. 145: * @param desc a description of the attribute. 146: * @param type the open type of the attribute. 147: * @param isReadable true if the attribute's value can be read. 148: * @param isWritable true if the attribute's value can be changed. 149: * @param isIs true if the attribute uses an accessor of the form isXXX. 150: * @param defaultValue the default value of the attribute. 151: * @throws IllegalArgumentException if the name, description or 152: * open type are <code>null</code> 153: * or the name or description are 154: * the empty string. 155: * @throws OpenDataException if <code>defaultValue<code> is non-null 156: * and is either not a value of the given 157: * open type or the open type is an instance 158: * of {@link ArrayType} or {@link TabularType}. 159: */ 160: public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type, 161: boolean isReadable, boolean isWritable, 162: boolean isIs, T defaultValue) 163: throws OpenDataException 164: { 165: this(name, desc, type, isReadable, isWritable, isIs, defaultValue, null); 166: } 167: 168: /** 169: * <p> 170: * Constructs a new {@link OpenMBeanAttributeInfo} using the 171: * specified name, description, open type, access properties, 172: * default, maximum and minimum values. The name, description 173: * and open type cannot be <code>null</code> and the name and 174: * description may not be equal to the empty string. The 175: * default, maximum and minimum values may be <code>null</code>. 176: * The following conditions apply when the attributes mentioned 177: * are non-null: 178: * </p> 179: * <ul> 180: * <li>The values must be valid values for the given open type.</li> 181: * <li>Default values are not applicable to the open types, {@link 182: * ArrayType} and {@link TabularType}.</li> 183: * <li>The minimum value must be smaller than or equal to the maximum value 184: * (literally, <code>minValue.compareTo(maxValue) <= 0</code>.</li> 185: * <li>The minimum value must be smaller than or equal to the default value 186: * (literally, <code>minValue.compareTo(defaultValue) <= 0</code>.</li> 187: * <li>The default value must be smaller than or equal to the maximum value 188: * (literally, <code>defaultValue.compareTo(maxValue) <= 0</code>.</li> 189: * </ul> 190: * 191: * @param name the name of the attribute. 192: * @param desc a description of the attribute. 193: * @param type the open type of the attribute. 194: * @param isReadable true if the attribute's value can be read. 195: * @param isWritable true if the attribute's value can be changed. 196: * @param isIs true if the attribute uses an accessor of the form isXXX. 197: * @param defaultValue the default value of the attribute, or <code>null</code>. 198: * @param minimumValue the minimum value of the attribute, or <code>null</code>. 199: * @param maximumValue the maximum value of the attribute, or <code>null</code>. 200: * @throws IllegalArgumentException if the name, description or 201: * open type are <code>null</code> 202: * or the name or description are 203: * the empty string. 204: * @throws OpenDataException if any condition in the list above is broken. 205: */ 206: @SuppressWarnings("unchecked") 207: public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type, 208: boolean isReadable, boolean isWritable, 209: boolean isIs, T defaultValue, 210: Comparable<T> minimumValue, 211: Comparable<T> maximumValue) 212: throws OpenDataException 213: { 214: this(name, desc, type, isReadable, isWritable, isIs); 215: if (defaultValue != null && !(type.isValue(defaultValue))) 216: throw new OpenDataException("The default value is not a member of the " + 217: "open type given."); 218: if (minimumValue != null && !(type.isValue(minimumValue))) 219: throw new OpenDataException("The minimum value is not a member of the " + 220: "open type given."); 221: if (maximumValue != null && !(type.isValue(maximumValue))) 222: throw new OpenDataException("The maximum value is not a member of the " + 223: "open type given."); 224: if (defaultValue != null && (type instanceof ArrayType || 225: type instanceof TabularType)) 226: throw new OpenDataException("Default values are not applicable for " + 227: "array or tabular types."); 228: if (minimumValue != null && maximumValue != null 229: && minimumValue.compareTo((T) maximumValue) > 0) 230: throw new OpenDataException("The minimum value is greater than the " + 231: "maximum."); 232: if (minimumValue != null && defaultValue != null 233: && minimumValue.compareTo(defaultValue) > 0) 234: throw new OpenDataException("The minimum value is greater than the " + 235: "default."); 236: if (defaultValue != null && maximumValue != null 237: && maximumValue.compareTo(defaultValue) < 0) 238: throw new OpenDataException("The default value is greater than the " + 239: "maximum."); 240: 241: openType = type; 242: this.defaultValue = defaultValue; 243: minValue = minimumValue; 244: maxValue = maximumValue; 245: } 246: 247: /** 248: * <p> 249: * Constructs a new {@link OpenMBeanAttributeInfo} using the 250: * specified name, description, open type, access properties, default 251: * value and set of legal values. The name, description and open type 252: * cannot be <code>null</code> and the name and description may not be 253: * equal to the empty string. The default, maximum and minimum values 254: * may be <code>null</code>. The following conditions apply when the 255: * attributes mentioned are non-null: 256: * </p> 257: * <ul> 258: * <li>The default value and each of the legal values must be a valid 259: * value for the given open type.</li> 260: * <li>Default and legal values are not applicable to the open types, {@link 261: * ArrayType} and {@link TabularType}.</li> 262: * <li>The default value is not in the set of legal values.</li> 263: * </ul> 264: * <p> 265: * The legal values are copied from the array into a unmodifiable set, 266: * so future modifications to the array have no effect. 267: * </p> 268: * 269: * @param name the name of the attribute. 270: * @param desc a description of the attribute. 271: * @param type the open type of the attribute. 272: * @param isReadable true if the attribute's value can be read. 273: * @param isWritable true if the attribute's value can be changed. 274: * @param isIs true if the attribute uses an accessor of the form isXXX. 275: * @param defaultValue the default value of the attribute, or <code>null</code>. 276: * @param legalValues the legal values of the attribute. May be 277: * <code>null</code> or an empty array. 278: * @throws IllegalArgumentException if the name, description or 279: * open type are <code>null</code> 280: * or the name or description are 281: * the empty string. 282: * @throws OpenDataException if any condition in the list above is broken. 283: */ 284: public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type, 285: boolean isReadable, boolean isWritable, 286: boolean isIs, T defaultValue, 287: T[] legalValues) 288: throws OpenDataException 289: { 290: this(name, desc, type, isReadable, isWritable, isIs); 291: if (defaultValue != null && !(type.isValue(defaultValue))) 292: throw new OpenDataException("The default value is not a member of the " + 293: "open type given."); 294: if (defaultValue != null && (type instanceof ArrayType || 295: type instanceof TabularType)) 296: throw new OpenDataException("Default values are not applicable for " + 297: "array or tabular types."); 298: if (legalValues != null && (type instanceof ArrayType || 299: type instanceof TabularType)) 300: throw new OpenDataException("Legal values are not applicable for " + 301: "array or tabular types."); 302: if (legalValues != null && legalValues.length > 0) 303: { 304: Set<T> lv = new HashSet<T>(legalValues.length); 305: for (int a = 0; a < legalValues.length; ++a) 306: { 307: if (legalValues[a] != null && 308: !(type.isValue(legalValues[a]))) 309: throw new OpenDataException("The legal value, " 310: + legalValues[a] + 311: "is not a member of the " + 312: "open type given."); 313: lv.add(legalValues[a]); 314: } 315: if (defaultValue != null && !(lv.contains(defaultValue))) 316: throw new OpenDataException("The default value is not in the set " + 317: "of legal values."); 318: this.legalValues = Collections.unmodifiableSet(lv); 319: } 320: openType = type; 321: this.defaultValue = defaultValue; 322: } 323: 324: /** 325: * Compares this attribute with the supplied object. This returns 326: * true iff the object is an instance of {@link OpenMBeanAttributeInfo} 327: * with an equal name and open type and the same default, minimum, 328: * maximum and legal values and the same access properties. 329: * 330: * @param obj the object to compare. 331: * @return true if the object is a {@link OpenMBeanAttributeInfo} 332: * instance, 333: * <code>name.equals(object.getName())</code>, 334: * <code>openType.equals(object.getOpenType())</code>, 335: * <code>isRead == object.isReadable()</code>, 336: * <code>isWrite == object.isWritable()</code>, 337: * <code>isIs == object.isIs()</code>, 338: * <code>defaultValue.equals(object.getDefaultValue())</code>, 339: * <code>minValue.equals(object.getMinValue())</code>, 340: * <code>maxValue.equals(object.getMaxValue())</code>, 341: * and <code>legalValues.equals(object.getLegalValues())</code>. 342: */ 343: public boolean equals(Object obj) 344: { 345: if (!(obj instanceof OpenMBeanAttributeInfo)) 346: return false; 347: OpenMBeanAttributeInfo o = (OpenMBeanAttributeInfo) obj; 348: return getName().equals(o.getName()) && 349: openType.equals(o.getOpenType()) && 350: isReadable() == o.isReadable() && 351: isWritable() == o.isWritable() && 352: isIs() == o.isIs() && 353: (defaultValue == null ? o.getDefaultValue() == null : 354: defaultValue.equals(o.getDefaultValue())) && 355: (minValue == null ? o.getMinValue() == null : 356: minValue.equals(o.getMinValue())) && 357: (maxValue == null ? o.getMaxValue() == null : 358: maxValue.equals(o.getMaxValue())) && 359: (legalValues == null ? o.getLegalValues() == null : 360: legalValues.equals(o.getLegalValues())); 361: } 362: 363: /** 364: * Returns the default value of this attribute, or <code>null</code> 365: * if there is no default value. 366: * 367: * @return the default value of the attribute, or <code>null</code> 368: * if there is no default. 369: */ 370: public Object getDefaultValue() 371: { 372: return defaultValue; 373: } 374: 375: /** 376: * Returns a {@link java.util.Set} enumerating the legal values 377: * of this attribute, or <code>null</code> if no such limited 378: * set exists for this attribute. 379: * 380: * @return a set of legal values, or <code>null</code> if no such 381: * set exists. 382: */ 383: public Set<?> getLegalValues() 384: { 385: return legalValues; 386: } 387: 388: /** 389: * Returns the maximum value of this attribute, or <code>null</code> 390: * if there is no maximum. 391: * 392: * @return the maximum value, or <code>null</code> if none exists. 393: */ 394: public Comparable<?> getMaxValue() 395: { 396: return maxValue; 397: } 398: 399: /** 400: * Returns the minimum value of this attribute, or <code>null</code> 401: * if there is no minimum. 402: * 403: * @return the minimum value, or <code>null</code> if none exists. 404: */ 405: public Comparable<?> getMinValue() 406: { 407: return minValue; 408: } 409: 410: /** 411: * Returns the open type instance which represents the type of this 412: * attribute. 413: * 414: * @return the open type of this attribute. 415: */ 416: public OpenType<?> getOpenType() 417: { 418: return openType; 419: } 420: 421: /** 422: * Returns true if this attribute has a default value 423: * (i.e. the value is non-null). 424: * 425: * @return true if this attribute has a default. 426: */ 427: public boolean hasDefaultValue() 428: { 429: return defaultValue != null; 430: } 431: 432: /** 433: * <p> 434: * Returns the hashcode of the attribute information as the sum of 435: * the hashcodes of the name, open type, default value, maximum 436: * value, minimum value and the set of legal values. 437: * </p> 438: * <p> 439: * As instances of this class are immutable, the hash code 440: * is computed just once for each instance and reused 441: * throughout its life. 442: * </p> 443: * 444: * @return the hashcode of the attribute information. 445: */ 446: public int hashCode() 447: { 448: if (hashCode == null) 449: hashCode = Integer.valueOf(getName().hashCode() + 450: openType.hashCode() + 451: Boolean.valueOf(isReadable()).hashCode() + 452: (2 * 453: Boolean.valueOf(isWritable()).hashCode()) + 454: (4 * Boolean.valueOf(isIs()).hashCode()) + 455: (defaultValue == null ? 0 : 456: defaultValue.hashCode()) + 457: (minValue == null ? 0 : 458: minValue.hashCode()) + 459: (maxValue == null ? 0 : 460: maxValue.hashCode()) + 461: (legalValues == null ? 0 : 462: legalValues.hashCode())); 463: return hashCode.intValue(); 464: } 465: 466: /** 467: * Returns true if there is a set of legal values for this 468: * attribute (i.e. the value is non-null). 469: * 470: * @return true if a set of legal values exists for this 471: * attribute. 472: */ 473: public boolean hasLegalValues() 474: { 475: return legalValues != null; 476: } 477: 478: /** 479: * Returns true if there is a maximum value for this attribute 480: * (i.e. the value is non-null). 481: * 482: * @return true if a maximum value exists for this attribute. 483: */ 484: public boolean hasMaxValue() 485: { 486: return maxValue != null; 487: } 488: 489: /** 490: * Returns true if there is a minimum value for this attribute. 491: * (i.e. the value is non-null). 492: * 493: * @return true if a minimum value exists for this attribute. 494: */ 495: public boolean hasMinValue() 496: { 497: return minValue != null; 498: } 499: 500: /** 501: * Returns true if the specified object is a valid value for 502: * this attribute. 503: * 504: * @param obj the object to test. 505: * @return true if <code>obj</code> is a valid value for this 506: * attribute. 507: */ 508: public boolean isValue(Object obj) 509: { 510: return openType.isValue(obj); 511: } 512: 513: /** 514: * <p> 515: * Returns a textual representation of this instance. This 516: * is constructed using the class name 517: * (<code>javax.management.openmbean.OpenMBeanAttributeInfo</code>) 518: * along with the name, open type, access properties, default, 519: * minimum, maximum and legal values of the attribute. 520: * </p> 521: * <p> 522: * As instances of this class are immutable, the return value 523: * is computed just once for each instance and reused 524: * throughout its life. 525: * </p> 526: * 527: * @return a @link{java.lang.String} instance representing 528: * the instance in textual form. 529: */ 530: public String toString() 531: { 532: if (string == null) 533: string = getClass().getName() 534: + "[name=" + getName() 535: + ",openType=" + openType 536: + ",isReadable=" + isReadable() 537: + ",isWritable=" + isWritable() 538: + ",isIs=" + isIs() 539: + ",defaultValue=" + defaultValue 540: + ",minValue=" + minValue 541: + ",maxValue=" + maxValue 542: + ",legalValues=" + legalValues 543: + "]"; 544: return string; 545: } 546: 547: }