javax.management.openmbean: public final class: SimpleType

javax.management.openmbean
public final class: SimpleType [javadoc | source]

java.lang.Object
   javax.management.openmbean.OpenType<T>
      javax.management.openmbean.SimpleType

All Implemented Interfaces:
Serializable

The SimpleType class is the open type class whose instances describe all open data values which are neither arrays, nor CompositeData values, nor TabularData values. It predefines all its possible instances as static fields, and has no public constructor.

Given a SimpleType instance describing values whose Java class name is className, the internal fields corresponding to the name and description of this SimpleType instance are also set to className. In other words, its methods getClassName, getTypeName and getDescription all return the same string value className.

since: 1.5 -

Field Summary
static final long	serialVersionUID
public static final SimpleType<Void>	VOID	The `SimpleType` instance describing values whose Java class name is `java.lang.Void`.
public static final SimpleType<Boolean>	BOOLEAN	The `SimpleType` instance describing values whose Java class name is `java.lang.Boolean`.
public static final SimpleType<Character>	CHARACTER	The `SimpleType` instance describing values whose Java class name is `java.lang.Character`.
public static final SimpleType<Byte>	BYTE	The `SimpleType` instance describing values whose Java class name is `java.lang.Byte`.
public static final SimpleType<Short>	SHORT	The `SimpleType` instance describing values whose Java class name is `java.lang.Short`.
public static final SimpleType<Integer>	INTEGER	The `SimpleType` instance describing values whose Java class name is `java.lang.Integer`.
public static final SimpleType<Long>	LONG	The `SimpleType` instance describing values whose Java class name is `java.lang.Long`.
public static final SimpleType<Float>	FLOAT	The `SimpleType` instance describing values whose Java class name is `java.lang.Float`.
public static final SimpleType<Double>	DOUBLE	The `SimpleType` instance describing values whose Java class name is `java.lang.Double`.
public static final SimpleType<String>	STRING	The `SimpleType` instance describing values whose Java class name is `java.lang.String`.
public static final SimpleType<BigDecimal>	BIGDECIMAL	The `SimpleType` instance describing values whose Java class name is `java.math.BigDecimal`.
public static final SimpleType<BigInteger>	BIGINTEGER	The `SimpleType` instance describing values whose Java class name is `java.math.BigInteger`.
public static final SimpleType<Date>	DATE	The `SimpleType` instance describing values whose Java class name is `java.util.Date`.
public static final SimpleType<ObjectName>	OBJECTNAME	The `SimpleType` instance describing values whose Java class name is `javax.management.ObjectName`.

Fields inherited from javax.management.openmbean.OpenType:
serialVersionUID, ALLOWED_CLASSNAMES_LIST, ALLOWED_CLASSNAMES

Method from javax.management.openmbean.SimpleType Summary:
equals, hashCode, isValue, readResolve, toString

Methods from javax.management.openmbean.OpenType:
equals, getClassName, getDescription, getDescriptor, getTypeName, hashCode, isArray, isAssignableFrom, isValue, safeGetClassName, toString

Methods from java.lang.Object:
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from javax.management.openmbean.SimpleType Detail:
public boolean equals(Object obj) { /* If it weren't for readReplace(), we could replace this method with just: return (this == obj); */ if (!(obj instanceof SimpleType< ? >)) return false; SimpleType< ? > other = (SimpleType< ? >) obj; // Test if other's className field is the same as for this instance // return this.getClassName().equals(other.getClassName()); } Compares the specified `obj` parameter with this `SimpleType` instance for equality. Two `SimpleType` instances are equal if and only if their getClassName methods return the same value.
public int hashCode() { // Calculate the hash code value if it has not yet been done (ie 1st call to hashCode()) // if (myHashCode == null) { myHashCode = Integer.valueOf(this.getClassName().hashCode()); } // return always the same hash code for this instance (immutable) // return myHashCode.intValue(); } Returns the hash code value for this `SimpleType` instance. The hash code of a `SimpleType` instance is the the hash code of the string value returned by the getClassName method. As `SimpleType` 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.
public boolean isValue(Object obj) { // if obj is null, return false // if (obj == null) { return false; } // Test if obj's class name is the same as for this instance // return this.getClassName().equals(obj.getClass().getName()); } Tests whether `obj` is a value for this `SimpleType` instance. This method returns `true` if and only if `obj` is not null and `obj`'s class name is the same as the className field defined for this `SimpleType` instance (ie the class name returned by the getClassName method).
public Object readResolve() throws ObjectStreamException { final SimpleType< ? > canonical = canonicalTypes.get(this); if (canonical == null) { // Should not happen throw new InvalidObjectException("Invalid SimpleType: " + this); } return canonical; } Replace an object read from an java.io.ObjectInputStream with the unique instance for that value.
public String toString() { // Calculate the string representation if it has not yet been done (ie 1st call to toString()) // if (myToString == null) { myToString = this.getClass().getName()+ "(name="+ getTypeName() +")"; } // return always the same string representation for this instance (immutable) // return myToString; } Returns a string representation of this `SimpleType` instance. The string representation consists of the name of this class (ie `javax.management.openmbean.SimpleType`) and the type name for this instance (which is the java class name of the values this `SimpleType` instance represents). As `SimpleType` 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.

Method from javax.management.openmbean.SimpleType Detail:

 public boolean equals(Object obj) {
        /* If it weren't for readReplace(), we could replace this method
           with just:
           return (this == obj);
        */
        if (!(obj instanceof SimpleType< ? >))
            return false;
        SimpleType< ? > other = (SimpleType< ? >) obj;
        // Test if other's className field is the same as for this instance
        //
        return this.getClassName().equals(other.getClassName());
}

obj

SimpleType

Two SimpleType instances are equal if and only if their getClassName methods return the same value.

 public int hashCode() {
        // Calculate the hash code value if it has not yet been done (ie 1st call to hashCode())
        //
        if (myHashCode == null) {
            myHashCode = Integer.valueOf(this.getClassName().hashCode());
        }
        // return always the same hash code for this instance (immutable)
        //
        return myHashCode.intValue();
}

SimpleType

getClassName

As SimpleType 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.

 public boolean isValue(Object obj) {
        // if obj is null, return false
        //
        if (obj == null) {
            return false;
        }
        // Test if obj's class name is the same as for this instance
        //
        return this.getClassName().equals(obj.getClass().getName());
}

obj

SimpleType

This method returns true if and only if obj is not null and obj's class name is the same as the className field defined for this SimpleType instance (ie the class name returned by the getClassName method).

 public Object readResolve() throws ObjectStreamException {
        final SimpleType< ? > canonical = canonicalTypes.get(this);
        if (canonical == null) {
            // Should not happen
            throw new InvalidObjectException("Invalid SimpleType: " + this);
        }
        return canonical;
}

java.io.ObjectInputStream

 public String toString() {
        // Calculate the string representation if it has not yet been done (ie 1st call to toString())
        //
        if (myToString == null) {
            myToString = this.getClass().getName()+ "(name="+ getTypeName() +")";
        }
        // return always the same string representation for this instance (immutable)
        //
        return myToString;
}

SimpleType

The string representation consists of the name of this class (ie javax.management.openmbean.SimpleType) and the type name for this instance (which is the java class name of the values this SimpleType instance represents).

As SimpleType 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.