OpenMBeanAttributeInfoSupportpublic class OpenMBeanAttributeInfoSupport extends MBeanAttributeInfo implements Serializable, OpenMBeanAttributeInfo| Describes an attribute of an open MBean. |
| Fields Summary |
|---|
| static final long | serialVersionUID | | private OpenType | openType | | private Object | defaultValue | | private Set | legalValues | | private Comparable | minValue | | private Comparable | maxValue | | private transient Integer | myHashCode | | private transient String | myToString |
| Constructors Summary |
|---|
public OpenMBeanAttributeInfoSupport(String name, String description, OpenType openType, boolean isReadable, boolean isWritable, boolean isIs)Constructs an OpenMBeanAttributeInfoSupport instance, which describes the attribute of an open MBean
with the specified name, openType and description,
and the specified read/write access properties. // need only be calculated once.
// Construct parent's state
//
super(name, ( (openType==null) ? null : openType.getClassName() ), description, isReadable, isWritable, isIs);
// check parameters that should not be null or empty (unfortunately it is not done in superclass :-( ! )
//
if ( (name == null) || (name.trim().equals("")) ) {
throw new IllegalArgumentException("Argument name cannot be null or empty.");
}
if (openType == null) {
throw new IllegalArgumentException("Argument openType cannot be null.");
}
if ( (description == null) || (description.trim().equals("")) ) {
throw new IllegalArgumentException("Argument description cannot be null or empty.");
}
// Initialize this instance's specific state
//
this.openType = openType;
| public OpenMBeanAttributeInfoSupport(String name, String description, OpenType openType, boolean isReadable, boolean isWritable, boolean isIs, Object defaultValue)Constructs an OpenMBeanAttributeInfoSupport instance, which describes the attribute of an open MBean
with the specified name, openType, description and defaultValue,
and the specified read/write access properties.
// First check and construct the part regarding name, openType and description
//
this(name, description, openType, isReadable, isWritable, isIs);
// Check and initialize defaultValue
//
if (defaultValue != null) {
// Default value not supported for ArrayType and TabularType
if ( (openType.isArray()) || (openType instanceof TabularType) ) {
throw new OpenDataException("Default value not supported for ArrayType and TabularType.");
}
// Check defaultValue's class
if ( ! openType.isValue(defaultValue) ) {
throw new OpenDataException("Argument defaultValue's class [\""+ defaultValue.getClass().getName() +
"\"] does not match the one defined in openType[\""+ openType.getClassName() +"\"].");
}
// Then initializes defaultValue:
// no need to clone it: apart from arrays and TabularData, basic data types are immutable
this.defaultValue = defaultValue;
}
| public OpenMBeanAttributeInfoSupport(String name, String description, OpenType openType, boolean isReadable, boolean isWritable, boolean isIs, Object defaultValue, Object[] legalValues)Constructs an OpenMBeanAttributeInfoSupport instance, which describes the attribute of an open MBean
with the specified name, openType, description,
defaultValue and legalValues,
and the specified read/write access properties.
The contents of legalValues are internally dumped into an unmodifiable Set,
so subsequent modifications of the array referenced by legalValues have no impact on
this OpenMBeanAttributeInfoSupport instance.
// First check and construct the part regarding name, openType, description and defaultValue
//
this(name, description, openType, isReadable, isWritable, isIs, defaultValue);
// Check and initialize legalValues
//
if ( (legalValues != null) && (legalValues.length > 0) ){
// legalValues not supported for TabularType and arrays
if ( (openType instanceof TabularType) || (openType.isArray()) ) {
throw new OpenDataException("Legal values not supported for TabularType and arrays");
}
// Check legalValues are valid with openType
for (int i = 0; i < legalValues.length; i++ ) {
if ( ! openType.isValue(legalValues[i]) ) {
throw new OpenDataException("Element legalValues["+ i +"]="+ legalValues[i] +
" is not a valid value for the specified openType ["+ openType.toString() +"].");
}
}
// dump the legalValues array content into a Set: ensures uniqueness of elements
// (and we could not keep the array reference as array content could be modified by the caller)
Set tmpSet = new HashSet(legalValues.length+1, 1);
for (int i = 0; i < legalValues.length; i++ ) {
tmpSet.add(legalValues[i]);
}
// initializes legalValues as an unmodifiable Set
this.legalValues = Collections.unmodifiableSet(tmpSet);
}
// Check that defaultValue is a legal value
//
if ( (this.hasDefaultValue()) && (this.hasLegalValues()) ) {
if ( ! this.legalValues.contains(defaultValue) ) {
throw new OpenDataException("defaultValue is not contained in legalValues");
}
}
| public OpenMBeanAttributeInfoSupport(String name, String description, OpenType openType, boolean isReadable, boolean isWritable, boolean isIs, Object defaultValue, Comparable minValue, Comparable maxValue)Constructs an OpenMBeanAttributeInfoSupport instance, which describes the attribute
used in one or more operations or constructors of a class of open MBeans,
with the specified name, openType, description,
defaultValue, minValue and maxValue.
It is possible to specify minimal and maximal values only for an open type
whose values are Comparable.
// First check and construct the part regarding name, openType, description and defaultValue
//
this(name, description, openType, isReadable, isWritable, isIs, defaultValue);
// Check and initialize minValue
//(note: no need to worry about Composite, Tabular and arrays as they are not Comparable)
//
if (minValue != null) {
if ( ! openType.isValue(minValue) ) {
throw new OpenDataException("Argument minValue's class [\""+ minValue.getClass().getName() +
"\"] does not match openType's definition [\""+ openType.getClassName() +"\"].");
}
// then initializes minValue
this.minValue = minValue;
}
// Check and initialize maxValue
//(note: no need to worry about Composite, Tabular and arrays as they are not Comparable)
//
if (maxValue != null) {
if ( ! openType.isValue(maxValue) ) {
throw new OpenDataException("Argument maxValue's class [\""+ maxValue.getClass().getName() +
"\"] does not match openType's definition [\""+ openType.getClassName() +"\"].");
}
// then initializes maxValue
this.maxValue = maxValue;
}
// Check that, if both specified, minValue <= maxValue
//
if (hasMinValue() && hasMaxValue()) {
if (minValue.compareTo(maxValue) > 0) {
throw new OpenDataException("minValue cannot be greater than maxValue.");
}
}
// Check that minValue <= defaultValue <= maxValue
//
if ( (this.hasDefaultValue()) && (this.hasMinValue()) ) {
if (minValue.compareTo((Comparable)defaultValue) > 0) {
throw new OpenDataException("minValue cannot be greater than defaultValue.");
}
}
if ( (this.hasDefaultValue()) && (this.hasMaxValue()) ) {
if (((Comparable)defaultValue).compareTo(maxValue) > 0) {
throw new OpenDataException("defaultValue cannot be greater than maxValue.");
}
}
|
| Methods Summary |
|---|
| public boolean | equals(java.lang.Object obj)Compares the specified obj parameter with this OpenMBeanAttributeInfoSupport instance for equality.
Returns true if and only if all of the following statements are true:
- obj is non null,
- obj also implements the
OpenMBeanAttributeInfo interface,
- their names are equal
- their open types are equal
- their access properties (isReadable, isWritable and isIs) are equal
- their default, min, max and legal values are equal.
This ensures that this equals method works properly for obj parameters which are
different implementations of the OpenMBeanAttributeInfo interface.
// if obj is null, return false
//
if (obj == null) {
return false;
}
// if obj is not a OpenMBeanAttributeInfo, return false
//
OpenMBeanAttributeInfo other;
try {
other = (OpenMBeanAttributeInfo) obj;
} catch (ClassCastException e) {
return false;
}
// Now, really test for equality between this OpenMBeanAttributeInfo implementation and the other:
//
// their Name should be equal
if ( ! this.getName().equals(other.getName()) ) {
return false;
}
// their OpenType should be equal
if ( ! this.getOpenType().equals(other.getOpenType()) ) {
return false;
}
// their access properties (isReadable, isWritable and isIs) are equal</li>
if ( (this.isReadable() != other.isReadable()) ||
(this.isWritable() != other.isWritable()) ||
(this.isIs() != other.isIs()) ) {
return false;
}
// their DefaultValue should be equal
if (this.hasDefaultValue()) {
if ( ! this.defaultValue.equals(other.getDefaultValue()) ) {
return false;
}
} else {
if (other.hasDefaultValue()) {
return false;
}
}
// their MinValue should be equal
if (this.hasMinValue()) {
if ( ! this.minValue.equals(other.getMinValue()) ) {
return false;
}
} else {
if (other.hasMinValue()) {
return false;
}
}
// their MaxValue should be equal
if (this.hasMaxValue()) {
if ( ! this.maxValue.equals(other.getMaxValue()) ) {
return false;
}
} else {
if (other.hasMaxValue()) {
return false;
}
}
// their LegalValues should be equal
if (this.hasLegalValues()) {
if ( ! this.legalValues.equals(other.getLegalValues()) ) {
return false;
}
} else {
if (other.hasLegalValues()) {
return false;
}
}
// All tests for equality were successfull
//
return true;
| | public java.lang.Object | getDefaultValue()Returns the default value for the attribute described by this OpenMBeanAttributeInfoSupport instance,
if specified, or null otherwise.
// Special case for ArrayType and TabularType
// [JF] TODO: clone it so that it cannot be altered,
// [JF] TODO: if we decide to support defaultValue as an array itself.
// [JF] As of today (oct 2000) it is not supported so defaultValue is null for arrays. Nothing to do.
return defaultValue;
| | public java.util.Set | getLegalValues()Returns an unmodifiable Set of legal values for the attribute described by this OpenMBeanAttributeInfoSupport instance,
if specified, or null otherwise.
// Special case for ArrayType and TabularType
// [JF] TODO: clone values so that they cannot be altered,
// [JF] TODO: if we decide to support LegalValues as an array itself.
// [JF] As of today (oct 2000) it is not supported so legalValues is null for arrays. Nothing to do.
// Returns our legalValues Set (set was constructed unmodifiable)
return (legalValues);
| | public java.lang.Comparable | getMaxValue()Returns the maximal value for the attribute described by this OpenMBeanAttributeInfoSupport instance,
if specified, or null otherwise.
// Note: only comparable values have a maxValue, so that's not the case of arrays and tabulars (always null).
return maxValue;
| | public java.lang.Comparable | getMinValue()Returns the minimal value for the attribute described by this OpenMBeanAttributeInfoSupport instance,
if specified, or null otherwise.
// Note: only comparable values have a minValue, so that's not the case of arrays and tabulars (always null).
return minValue;
| | public javax.management.openmbean.OpenType | getOpenType()Returns the open type for the values of the attribute described by this OpenMBeanAttributeInfoSupport instance.
return openType;
| | public boolean | hasDefaultValue()Returns true if this OpenMBeanAttributeInfoSupport instance specifies a non-null default value
for the described attribute, false otherwise.
return (defaultValue != null);
| | public boolean | hasLegalValues()Returns true if this OpenMBeanAttributeInfoSupport instance specifies a non-null set of legal values
for the described attribute, false otherwise.
return (legalValues != null);
| | public boolean | hasMaxValue()Returns true if this OpenMBeanAttributeInfoSupport instance specifies a non-null maximal value
for the described attribute, false otherwise.
return (maxValue != null);
| | public boolean | hasMinValue()Returns true if this OpenMBeanAttributeInfoSupport instance specifies a non-null minimal value
for the described attribute, false otherwise.
return (minValue != null);
| | public int | hashCode()Returns the hash code value for this OpenMBeanAttributeInfoSupport instance.
The hash code of an OpenMBeanAttributeInfoSupport instance is the sum of the hash codes
of all elements of information used in equals comparisons
(ie: its name, its open type, and its default, min, max and legal values).
This ensures that t1.equals(t2) implies that t1.hashCode()==t2.hashCode()
for any two OpenMBeanAttributeInfoSupport instances t1 and t2,
as required by the general contract of the method
{@link Object#hashCode() Object.hashCode()}.
However, note that another instance of a class implementing the OpenMBeanAttributeInfo interface
may be equal to this OpenMBeanAttributeInfoSupport instance as defined by {@link #equals(java.lang.Object)},
but may have a different hash code if it is calculated differently.
As OpenMBeanAttributeInfoSupport instances are immutable, the hash code for this instance is calculated once,
on the first call to hashCode, and then the same value is returned for subsequent calls.
// Calculate the hash code value if it has not yet been done (ie 1st call to hashCode())
//
if (myHashCode == null) {
int value = 0;
value += this.getName().hashCode();
value += this.openType.hashCode();
if (this.hasDefaultValue()) {
value += this.defaultValue.hashCode();
}
if (this.hasMinValue()) {
value += this.minValue.hashCode();
}
if (this.hasMaxValue()) {
value += this.maxValue.hashCode();
}
if (this.hasLegalValues()) {
value += this.legalValues.hashCode();
}
myHashCode = new Integer(value);
}
// return always the same hash code for this instance (immutable)
//
return myHashCode.intValue();
| | public boolean | isValue(java.lang.Object obj)Tests whether obj is a valid value for the attribute
described by this OpenMBeanAttributeInfoSupport
instance.
boolean result;
if ( hasDefaultValue() && obj == null ) {
result = true;
}
else if ( ! openType.isValue(obj) ) {
result = false;
}
else if ( hasLegalValues() && ! legalValues.contains(obj) ) {
result = false;
}
else if ( hasMinValue() && (minValue.compareTo(obj)>0) ) {
result = false;
}
else if ( hasMaxValue() && (maxValue.compareTo(obj)<0) ) {
result = false;
}
else {
result = true;
}
return result;
| | public java.lang.String | toString()Returns a string representation of this OpenMBeanAttributeInfoSupport instance.
The string representation consists of the name of this class (ie javax.management.openmbean.OpenMBeanAttributeInfoSupport),
the string representation of the name and open type of the described parameter,
and the string representation of its default, min, max and legal values.
As OpenMBeanAttributeInfoSupport instances are immutable, the string representation for this instance is calculated once,
on the first call to toString, and then the same value is returned for subsequent calls.
// Calculate the hash code value if it has not yet been done (ie 1st call to hashCode())
//
if (myToString == null) {
myToString = new StringBuffer()
.append(this.getClass().getName())
.append("(name=")
.append(this.getName())
.append(",openType=")
.append(this.openType.toString())
.append(",default=")
.append(String.valueOf(this.defaultValue))
.append(",min=")
.append(String.valueOf(this.minValue))
.append(",max=")
.append(String.valueOf(this.maxValue))
.append(",legals=")
.append(String.valueOf(this.legalValues))
.append(")")
.toString();
}
// return always the same string representation for this instance (immutable)
//
return myToString;
|
|
