null.
*
* @param desc a description of the attribute.
* @param cons the constructor.
*/
public MBeanConstructorInfo(String desc, Constructor cons)
{
super(cons.getName(), desc);
Type[] paramTypes = cons.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);
}
}
/**
* Constructs a @link{MBeanConstructorInfo} with the specified
* name, description and parameter information. 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 constructor.
* @param sig the signature of the constructor, as a series
* of {@link MBeanParameterInfo} objects, one for
* each parameter.
*/
public MBeanConstructorInfo(String name, String desc,
MBeanParameterInfo[] sig)
{
super(name, desc);
if (sig == null)
signature = new MBeanParameterInfo[0];
else
{
signature = new MBeanParameterInfo[sig.length];
System.arraycopy(sig, 0, signature, 0, sig.length);
}
}
/**
* 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),
* 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 MBeanConstructorInfo}
* instance,
* name.equals(object.getName()),
* description.equals(object.getDescription())
* and the corresponding elements of the signature arrays are
* equal.
*/
public boolean equals(Object obj)
{
if (!(obj instanceof MBeanConstructorInfo))
return false;
if (!(super.equals(obj)))
return false;
MBeanConstructorInfo o = (MBeanConstructorInfo) 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 true;
}
/**
* Returns the constructor's signature, in the form of
* information on each parameter. Each parameter is
* described by an instance of {@link MBeanParameterInfo}.
* The returned array is a shallow copy of the array used
* by this instance, so changing which elements are stored
* in the array won't affect the array used by this, but
* changing the actual elements will affect the ones used
* here.
*
* @return an array of {@link MBeanParameterInfo} objects,
* describing the constructor parameters.
*/
public MBeanParameterInfo[] getSignature()
{
return (MBeanParameterInfo[]) signature.clone();
}
/**
* Returns the hashcode of the constructor information as the sum
* of the hashcode of the superclass and the hashcode of the parameter
* array.
*
* @return the hashcode of the constructor information.
*/
public int hashCode()
{
return super.hashCode() + Arrays.hashCode(signature);
}
/**
*
* Returns a textual representation of this instance. This
* is constructed using the class name
* (javax.management.MBeanConstructorInfo),
* the name and description of the constructor 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) { super.toString(); string = string.substring(0, string.length() - 1) + ",signature=" + Arrays.toString(signature) + "]"; } return string; } }