public OpenMBeanOperationInfoSupport(String name,
    String description,
    OpenMBeanParameterInfo[] signature,
    OpenType<?> returnOpenType,
    int impact) 
{
        this(name, description, signature, returnOpenType, impact,
             (Descriptor) null);
}

Constructs an {@code OpenMBeanOperationInfoSupport} instance, which describes the operation of a class of open MBeans, with the specified {@code name}, {@code description}, {@code signature}, {@code returnOpenType} and {@code impact}.

The {@code signature} array parameter is internally copied, so that subsequent changes to the array referenced by {@code signature} have no effect on this instance.

Parameters:

name - cannot be a null or empty string.

description - cannot be a null or empty string.

signature - can be null or empty if there are no parameters to describe.

returnOpenType - cannot be null: use {@code SimpleType.VOID} for operations that return nothing.

impact - must be one of {@code ACTION}, {@code ACTION_INFO}, {@code INFO}, or {@code UNKNOWN}.

Throws:

IllegalArgumentException - if {@code name} or {@code description} are null or empty string, or {@code returnOpenType} is null, or {@code impact} is not one of {@code ACTION}, {@code ACTION_INFO}, {@code INFO}, or {@code UNKNOWN}.

ArrayStoreException - If {@code signature} is not an array of instances of a subclass of {@code MBeanParameterInfo}.

 public OpenMBeanOperationInfoSupport(String name,
    String description,
    OpenMBeanParameterInfo[] signature,
    OpenType<?> returnOpenType,
    int impact,
    Descriptor descriptor) 
{
        super(name,
              description,
              arrayCopyCast(signature),
              // must prevent NPE here - we will throw IAE later on if
              // returnOpenType is null
              (returnOpenType == null) ? null : returnOpenType.getClassName(),
              impact,
              ImmutableDescriptor.union(descriptor,
                // must prevent NPE here - we will throw IAE later on if
                // returnOpenType is null
                (returnOpenType==null) ? null :returnOpenType.getDescriptor()));
        // 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 (description == null || description.trim().equals("")) {
            throw new IllegalArgumentException("Argument description cannot " +
                                               "be null or empty");
        }
        if (returnOpenType == null) {
            throw new IllegalArgumentException("Argument returnOpenType " +
                                               "cannot be null");
        }
        if (impact != ACTION && impact != ACTION_INFO && impact != INFO &&
                impact != UNKNOWN) {
            throw new IllegalArgumentException("Argument impact can only be " +
                                               "one of ACTION, ACTION_INFO, " +
                                               "INFO, or UNKNOWN: " + impact);
        }
        this.returnOpenType = returnOpenType;
}

Constructs an {@code OpenMBeanOperationInfoSupport} instance, which describes the operation of a class of open MBeans, with the specified {@code name}, {@code description}, {@code signature}, {@code returnOpenType}, {@code impact}, and {@code descriptor}.

The {@code signature} array parameter is internally copied, so that subsequent changes to the array referenced by {@code signature} have no effect on this instance.

Parameters:

name - cannot be a null or empty string.

description - cannot be a null or empty string.

signature - can be null or empty if there are no parameters to describe.

returnOpenType - cannot be null: use {@code SimpleType.VOID} for operations that return nothing.

impact - must be one of {@code ACTION}, {@code ACTION_INFO}, {@code INFO}, or {@code UNKNOWN}.

descriptor - The descriptor for the operation. This may be null, which is equivalent to an empty descriptor.

Throws:

IllegalArgumentException - if {@code name} or {@code description} are null or empty string, or {@code returnOpenType} is null, or {@code impact} is not one of {@code ACTION}, {@code ACTION_INFO}, {@code INFO}, or {@code UNKNOWN}.

ArrayStoreException - If {@code signature} is not an array of instances of a subclass of {@code MBeanParameterInfo}.

since: 1.6 -

 public boolean equals(Object obj) 
{
        // if obj is null, return false
        //
        if (obj == null) {
            return false;
        }
        // if obj is not a OpenMBeanOperationInfo, return false
        //
        OpenMBeanOperationInfo other;
        try {
            other = (OpenMBeanOperationInfo) obj;
        } catch (ClassCastException e) {
            return false;
        }
        // Now, really test for equality between this
        // OpenMBeanOperationInfo implementation and the other:
        //
        // their Name should be equal
        if ( ! this.getName().equals(other.getName()) ) {
            return false;
        }
        // their Signatures should be equal
        if ( ! Arrays.equals(this.getSignature(), other.getSignature()) ) {
            return false;
        }
        // their return open types should be equal
        if ( ! this.getReturnOpenType().equals(other.getReturnOpenType()) ) {
            return false;
        }
        // their impacts should be equal
        if ( this.getImpact() != other.getImpact() ) {
            return false;
        }
        // All tests for equality were successfull
        //
        return true;
}

Compares the specified {@code obj} parameter with this {@code OpenMBeanOperationInfoSupport} instance for equality.

Returns {@code true} if and only if all of the following statements are true:

• {@code obj} is non null,
• {@code obj} also implements the {@code OpenMBeanOperationInfo} interface,
• their names are equal
• their signatures are equal
• their return open types are equal
• their impacts are equal
This ensures that this {@code equals} method works properly for {@code obj} parameters which are different implementations of the {@code OpenMBeanOperationInfo} interface.

 public OpenType<?> getReturnOpenType() 
{
        return returnOpenType;
}

Returns the open type of the values returned by the operation described by this {@code OpenMBeanOperationInfo} instance.

 public int hashCode() 
{
        // 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 += Arrays.asList(this.getSignature()).hashCode();
            value += this.getReturnOpenType().hashCode();
            value += this.getImpact();
            myHashCode = Integer.valueOf(value);
        }
        // return always the same hash code for this instance (immutable)
        //
        return myHashCode.intValue();
}

Returns the hash code value for this {@code OpenMBeanOperationInfoSupport} instance.

The hash code of an {@code OpenMBeanOperationInfoSupport} instance is the sum of the hash codes of all elements of information used in {@code equals} comparisons (ie: its name, return open type, impact and signature, where the signature hashCode is calculated by a call to {@code java.util.Arrays.asList(this.getSignature).hashCode()}).

This ensures that {@code t1.equals(t2) } implies that {@code t1.hashCode()==t2.hashCode() } for any two {@code OpenMBeanOperationInfoSupport} instances {@code t1} and {@code t2}, as required by the general contract of the method Object.hashCode() .

However, note that another instance of a class implementing the {@code OpenMBeanOperationInfo} interface may be equal to this {@code OpenMBeanOperationInfoSupport} instance as defined by #equals(java.lang.Object) , but may have a different hash code if it is calculated differently.

As {@code OpenMBeanOperationInfoSupport} instances are immutable, the hash code for this instance is calculated once, on the first call to {@code hashCode}, and then the same value is returned for subsequent calls.

 public String toString() 
{
        // Calculate the hash code value if it has not yet been done
        // (ie 1st call to toString())
        //
        if (myToString == null) {
            myToString = new StringBuilder()
                .append(this.getClass().getName())
                .append("(name=")
                .append(this.getName())
                .append(",signature=")
                .append(Arrays.asList(this.getSignature()).toString())
                .append(",return=")
                .append(this.getReturnOpenType().toString())
                .append(",impact=")
                .append(this.getImpact())
                .append(",descriptor=")
                .append(this.getDescriptor())
                .append(")")
                .toString();
        }
        // return always the same string representation for this
        // instance (immutable)
        //
        return myToString;
}

Returns a string representation of this {@code OpenMBeanOperationInfoSupport} instance.

The string representation consists of the name of this class (ie {@code javax.management.openmbean.OpenMBeanOperationInfoSupport}), and the name, signature, return open type and impact of the described operation and the string representation of its descriptor.

As {@code OpenMBeanOperationInfoSupport} instances are immutable, the string representation for this instance is calculated once, on the first call to {@code toString}, and then the same value is returned for subsequent calls.