null. The return type and impact of the
* method are determined from the {@link Method} instance.
*
* @param desc a description of the attribute.
* @param method the method.
*/
public MBeanOperationInfo(String desc, Method method)
{
super(method.getName(), desc);
Type[] paramTypes = method.getGenericParameterTypes();
signature = new MBeanParameterInfo[paramTypes.length];
for (int a = 0; a < paramTypes.length; ++a)
{
Type t = paramTypes[a];
if (t instanceof Class)
signature[a] = new MBeanParameterInfo(null,
((Class) t).getName(),
null);
else
signature[a] = new MBeanParameterInfo(null, t.toString(), null);
}
Type retType = method.getGenericReturnType();
if (retType instanceof Class)
type = ((Class) retType).getName();
else
type = retType.toString();
if (method.getReturnType() == Void.TYPE)
{
if (paramTypes.length == 0)
impact = UNKNOWN;
else
impact = ACTION;
}
else
{
if (paramTypes.length == 0)
impact = INFO;
else
impact = ACTION_INFO;
}
}
/**
* Constructs a @link{MBeanOperationInfo} with the specified name,
* description, parameter information, return type and impact. A
* null value for the parameter information is the same
* as passing in an empty array. A copy of the parameter array is
* taken, so later changes have no effect.
*
* @param name the name of the constructor.
* @param desc a description of the attribute.
* @param sig the signature of the method, as a series
* of {@link MBeanParameterInfo} objects, one for
* each parameter.
* @param type the return type of the method, as the class name.
* @param impact the impact of performing the operation.
*/
public MBeanOperationInfo(String name, String desc,
MBeanParameterInfo[] sig, String type,
int impact)
{
super(name, desc);
if (sig == null)
signature = new MBeanParameterInfo[0];
else
{
signature = new MBeanParameterInfo[sig.length];
System.arraycopy(sig, 0, signature, 0, sig.length);
}
this.type = type;
this.impact = impact;
}
/**
* 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
* MBeanConstructorInfo}, {@link Object#equals()} returns true for a
* comparison of both the name and description of this notification
* with that of the specified object (performed by the superclass),
* the return type and impact are equal and the two signature arrays
* contain the same elements in the same order (but one may be
* longer than the other).
*
* @param obj the object to compare.
* @return true if the object is a {@link MBeanOperationInfo}
* instance,
* name.equals(object.getName()),
* description.equals(object.getDescription()),
* type.equals(object.getReturnType()),
* impact == object.getImpact(),
* and the corresponding elements of the signature arrays are
* equal.
*/
public boolean equals(Object obj)
{
if (!(obj instanceof MBeanOperationInfo))
return false;
if (!(super.equals(obj)))
return false;
MBeanOperationInfo o = (MBeanOperationInfo) obj;
MBeanParameterInfo[] sig = o.getSignature();
for (int a = 0; a < signature.length; ++a)
{
if (a == sig.length)
return true;
if (!(signature[a].equals(sig[a])))
return false;
}
return (type.equals(o.getReturnType()) &&
impact == o.getImpact());
}
/**
* * Returns the impact of performing this operation. * The value is equal to one of the following: *
*
* Returns a textual representation of this instance. This
* is constructed using the class name
* (javax.management.MBeanOperationInfo),
* the name, description, return type and impact of the
* operation and the contents of the array of parameters.
*
* 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) { String impactString; switch (impact) { case INFO: impactString = "INFO"; break; case ACTION: impactString = "ACTION"; break; case ACTION_INFO: impactString = "ACTION_INFO"; break; case UNKNOWN: impactString = "UNKNOWN"; break; default: impactString = "ERRONEOUS VALUE"; } super.toString(); string = string.substring(0, string.length() - 1) + ",returnType=" + type + ",impact=" + impactString + ",signature=" + Arrays.toString(signature) + "]"; } return string; } }