| /* SimpleType.java -- Open type descriptor for the base types. |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package javax.management.openmbean; |
| |
| import java.io.InvalidObjectException; |
| import java.io.ObjectStreamException; |
| |
| /** |
| * The open type descriptor for data values that are members |
| * of one of the simple types (such as an integer or a string). |
| * The other open types ({@link ArrayType}, {@link CompositeType}, |
| * {@link TabularType}) are constructed from one or more of these |
| * types. The simple types are formed from a small subset of |
| * basic Java types. As a result, the valid instances of this |
| * class are predefined, and no constructor is given for creating |
| * new instances. |
| * |
| * @author Andrew John Hughes (gnu_andrew@member.fsf.org) |
| * @since 1.5 |
| */ |
| public class SimpleType |
| extends OpenType |
| { |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.math.BigDecimal</code>. |
| */ |
| public static final SimpleType BIGDECIMAL; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.math.BigInteger</code>. |
| */ |
| public static final SimpleType BIGINTEGER; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Boolean</code>. |
| */ |
| public static final SimpleType BOOLEAN; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Byte</code>. |
| */ |
| public static final SimpleType BYTE; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Character</code>. |
| */ |
| public static final SimpleType CHARACTER; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.util.Date</code>. |
| */ |
| public static final SimpleType DATE; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Double</code>. |
| */ |
| public static final SimpleType DOUBLE; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Float</code>. |
| */ |
| public static final SimpleType FLOAT; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Integer</code>. |
| */ |
| public static final SimpleType INTEGER; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Long</code>. |
| */ |
| public static final SimpleType LONG; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>javax.management.ObjectName</code>. |
| */ |
| public static final SimpleType OBJECTNAME; |
| |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Short</code>. |
| */ |
| public static final SimpleType SHORT; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.String</code>. |
| */ |
| public static final SimpleType STRING; |
| |
| /** |
| * The {@link SimpleType} representation of |
| * <code>java.lang.Void</code>. |
| */ |
| public static final SimpleType VOID; |
| |
| /** |
| * Compatible with JDK 1.5 |
| */ |
| private static final long serialVersionUID = 2215577471957694503L; |
| |
| /** |
| * The hash code of this instance. |
| */ |
| private transient Integer hashCode; |
| |
| /** |
| * The <code>toString()</code> result of this instance. |
| */ |
| private transient String string; |
| |
| /** |
| * Static construction of the {@link SimpleType} instances. |
| */ |
| static |
| { |
| try |
| { |
| BIGDECIMAL = new SimpleType("java.math.BigDecimal"); |
| BIGINTEGER = new SimpleType("java.math.BigInteger"); |
| BOOLEAN = new SimpleType("java.lang.Boolean"); |
| BYTE = new SimpleType("java.lang.Byte"); |
| CHARACTER = new SimpleType("java.lang.Character"); |
| DATE = new SimpleType("java.util.Date"); |
| DOUBLE = new SimpleType("java.lang.Double"); |
| FLOAT = new SimpleType("java.lang.Float"); |
| INTEGER = new SimpleType("java.lang.Integer"); |
| LONG = new SimpleType("java.lang.Long"); |
| OBJECTNAME = new SimpleType("javax.management.ObjectName"); |
| SHORT = new SimpleType("java.lang.Short"); |
| STRING = new SimpleType("java.lang.String"); |
| VOID = new SimpleType("java.lang.Void"); |
| } |
| catch (OpenDataException e) |
| { |
| /* In normal circumstances, this shouldn't be possible. */ |
| throw new IllegalStateException("A invalid class name " + |
| "was passed to the SimpleType " + |
| "constructor."); |
| } |
| } |
| |
| /** |
| * Constructs a new {@link SimpleType} instance for the given |
| * class name. The class name is also used as the type name |
| * and description of the {@link OpenType} instance. |
| * |
| * @param name the name of the class this instance should |
| * represent. |
| * @throws OpenDataException if somehow the constructor of the |
| * superclass is passed an invalid |
| * class name. |
| */ |
| private SimpleType(String name) |
| throws OpenDataException |
| { |
| super(name, name, name); |
| } |
| |
| /** |
| * <p> |
| * Compares this simple data type with another object |
| * for equality. The objects are judged to be equal if: |
| * </p> |
| * <ul> |
| * <li><code>obj</code> is not null.</li> |
| * <li><code>obj</code> is an instance of |
| * {@link SimpleType}.</li> |
| * <li>The class names are equal.</li> |
| * </ul> |
| * |
| * @param obj the object to compare with. |
| * @return true if the conditions above hold. |
| */ |
| public boolean equals(Object obj) |
| { |
| if (!(obj instanceof SimpleType)) |
| return false; |
| SimpleType sType = (SimpleType) obj; |
| return sType.getClassName().equals(getClassName()); |
| } |
| |
| /** |
| * <p> |
| * Returns the hash code of the simple data type. |
| * This is simply the hash code of the class name, |
| * which is the same element of the type compared |
| * as part of the |
| * {@link #equals(java.lang.Object)} method, thus ensuring |
| * that the hashcode is compatible with the equality |
| * test. |
| * </p> |
| * <p> |
| * As instances of this class are immutable, the hash code |
| * is computed just once for each instance and reused |
| * throughout its life. |
| * </p> |
| * |
| * @return the hash code of this instance. |
| */ |
| public int hashCode() |
| { |
| if (hashCode == null) |
| hashCode = Integer.valueOf(getClassName().hashCode()); |
| return hashCode.intValue(); |
| } |
| |
| /** |
| * Returns true if the specified object is a member of this |
| * simple type. The object is judged to be so if it is |
| * non-null and its class name is the same as that returned |
| * by {@link SimpleType#getClassName()}. |
| * |
| * @param obj the object to test for membership. |
| * @return true if the object is a member of this type. |
| */ |
| public boolean isValue(Object obj) |
| { |
| if (obj == null) |
| return false; |
| return obj.getClass().getName().equals(getClassName()); |
| } |
| |
| /** |
| * Replaces instances of this class read from an |
| * {@link java.io.ObjectInputStream} with one of the predefined |
| * values. This ensures that each existing instance of |
| * this class is one of these unique instances. |
| * |
| * @return the replacement object. |
| * @throws ObjectStreamException if the object can not be |
| * resolved. |
| */ |
| public Object readResolve() |
| throws ObjectStreamException |
| { |
| if (equals(BIGDECIMAL)) |
| return BIGDECIMAL; |
| if (equals(BIGINTEGER)) |
| return BIGINTEGER; |
| if (equals(BOOLEAN)) |
| return BOOLEAN; |
| if (equals(BYTE)) |
| return BYTE; |
| if (equals(CHARACTER)) |
| return CHARACTER; |
| if (equals(DATE)) |
| return DATE; |
| if (equals(DOUBLE)) |
| return DOUBLE; |
| if (equals(FLOAT)) |
| return FLOAT; |
| if (equals(INTEGER)) |
| return INTEGER; |
| if (equals(LONG)) |
| return LONG; |
| if (equals(OBJECTNAME)) |
| return OBJECTNAME; |
| if (equals(SHORT)) |
| return SHORT; |
| if (equals(STRING)) |
| return STRING; |
| if (equals(VOID)) |
| return VOID; |
| throw new InvalidObjectException("Invalid simple type instance " + |
| "deserialized."); |
| } |
| |
| /** |
| * <p> |
| * Returns a textual representation of this instance. This |
| * is constructed using the class name |
| * (<code>javax.management.openmbean.SimpleType</code>) |
| * and the name of the class the type represents. |
| * </p> |
| * <p> |
| * As instances of this class are immutable, the return value |
| * is computed just once for each instance and reused |
| * throughout its life. |
| * </p> |
| * |
| * @return a @link{java.lang.String} instance representing |
| * the instance in textual form. |
| */ |
| public String toString() |
| { |
| if (string == null) |
| string = getClass().getName() |
| + "[name=" + getClassName() |
| + "]"; |
| return string; |
| } |
| |
| } |