null value for the accessor method
* indicates that the value can not be read. A null
* value for the mutator method indicates that the value can not be
* changed.
*
* @param name the name of the attribute.
* @param desc a description of the attribute.
* @param getter the accessor method, or null if the value
* can not be read.
* @param setter the mutator method, or null if the value
* can not be changed.
* @throws IntrospectionException if both the accessor and mutator method
* are null.
*/
public MBeanAttributeInfo(String name, String desc,
Method getter, Method setter)
throws IntrospectionException
{
super(name, desc);
if (getter == null && setter == null)
throw new IntrospectionException("Both the getter and setter methods can " +
"not be null.");
if (getter == null)
{
Type t = setter.getGenericParameterTypes()[0];
if (t instanceof Class)
attributeType = ((Class) t).getName();
else
attributeType = t.toString();
isRead = false;
is = false;
}
else
{
Type t = getter.getGenericReturnType();
if (t instanceof Class)
attributeType = ((Class) t).getName();
else
attributeType = t.toString();
isRead = true;
is = getter.getName().startsWith("is");
}
if (setter != null)
isWrite = true;
}
/**
* Constructs a new {@link MBeanAttributeInfo} using the specified
* name, description and type with the given settings for the accessor
* and mutator methods.
*
* @param name the name of the attribute.
* @param type the type of the attribute, in the form of its class name.
* @param desc a description of the attribute.
* @param isReadable true if the attribute's value can be read.
* @param isWritable true if the attribute's value can be changed.
* @param isIs true if the attribute uses an accessor of the form isXXX.
* @throws IllegalArgumentException if the attribute is both unreadable
* and unwritable.
*/
public MBeanAttributeInfo(String name, String type, String desc,
boolean isReadable, boolean isWritable,
boolean isIs)
{
super(name, desc);
if (!isReadable && !isWritable)
throw new IllegalArgumentException("The attribute can not be both " +
"unreadable and unwritable.");
attributeType = type;
isRead = isReadable;
isWrite = isWritable;
is = isIs;
}
/**
* Returns a clone of this instance. The clone is created
* using just the method provided by {@link java.lang.Object}.
* Thus, the clone is just a shallow clone as returned by
* that method, and does not contain any deeper cloning based
* on the subject of this class.
*
* @return a clone of this instance.
* @see java.lang.Cloneable
*/
public Object clone()
{
try
{
return super.clone();
}
catch (CloneNotSupportedException e)
{
/* This shouldn't happen; we implement Cloneable */
throw new IllegalStateException("clone() called on " +
"non-cloneable object.");
}
}
/**
* Compares this feature with the supplied object. This
* returns true iff the object is an instance of
* {@link MBeanAttributeInfo}, {@link Object#equals()}
* returns true for a comparison of both the name and
* description of this attribute with that of the specified
* object (performed by the superclass), and the type and
* boolean flags of the two instances are equal.
*
* @param obj the object to compare.
* @return true if the object is a {@link MBeanAttributeInfo}
* instance,
* name.equals(object.getName()),
* description.equals(object.getDescription()),
* attributeType.equals(object.getType()),
* isRead == object.isReadable(),
* isWrite == object.isWritable(),
* is == object.isIs()
*/
public boolean equals(Object obj)
{
if (!(obj instanceof MBeanAttributeInfo))
return false;
if (!(super.equals(obj)))
return false;
MBeanAttributeInfo o = (MBeanAttributeInfo) obj;
return (attributeType.equals(o.getType()) &&
isRead == o.isReadable() &&
isWrite == o.isWritable() &&
is == o.isIs());
}
/**
* Returns the type of this attribute, in the form of its class name.
*
* @return the type of this attribute.
*/
public String getType()
{
return attributeType;
}
/**
* Returns the hashcode of the attribute information as the sum of
* the hashcode of the superclass, the hashcode of the type,
* the hashcode of {@link #isReadable()}, twice the hashcode
* of {@link #isWritable()} and four times the hashcode
* of {@link #isIs()}.
*
* @return the hashcode of the attribute information.
*/
public int hashCode()
{
return super.hashCode() + attributeType.hashCode()
+ Boolean.valueOf(isRead).hashCode()
+ (2 * Boolean.valueOf(isWrite).hashCode())
+ (4 * Boolean.valueOf(is).hashCode());
}
/**
* Returns true if the accessor method of this attribute
* is of the form isXXX.
*
* @return true if the accessor takes the form isXXX.
*/
public boolean isIs()
{
return is;
}
/**
* Returns true if value of this attribute can be read.
*
* @return true if the value of the attribute can be read.
*/
public boolean isReadable()
{
return isRead;
}
/**
* Returns true if the value of this attribute can be changed.
*
* @return true if the value of the attribute can be changed.
*/
public boolean isWritable()
{
return isWrite;
}
/**
*
* Returns a textual representation of this instance. This
* is constructed using the class name
* (javax.management.MBeanAttributeInfo),
* the name, description and type of the attribute and the
* current settings of the {@link #isReadable()},
* {@link #isWritable()} and {@link #isIs()} properties.
*
* As instances of this class are immutable, the return value * is computed just once for each instance and reused * throughout its life. *
* * @return a @link{java.lang.String} instance representing * the instance in textual form. */ public String toString() { if (string == null) { super.toString(); string = string.substring(0, string.length() - 1) + ",type=" + attributeType + ",isReadable=" + (isRead ? "yes" : "no") + ",isWritable=" + (isWrite ? "yes" : "no") + ",isIs=" + (is ? "yes" : "no") + "]"; } return string; } }