libjava/classpath/javax/management/openmbean/SimpleType.java

   1 /* SimpleType.java -- Open type descriptor for the base types.
   2    Copyright (C) 2006, 2007 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package javax.management.openmbean;
  39
  40 import java.io.InvalidObjectException;
  41 import java.io.ObjectStreamException;
  42
  43 import java.math.BigDecimal;
  44 import java.math.BigInteger;
  45
  46 import java.util.Date;
  47
  48 import javax.management.ObjectName;
  49
  50 /**
  51  * The open type descriptor for data values that are members
  52  * of one of the simple types (such as an integer or a string).
  53  * The other open types ({@link ArrayType}, {@link CompositeType},
  54  * {@link TabularType}) are constructed from one or more of these
  55  * types.  The simple types are formed from a small subset of
  56  * basic Java types.  As a result, the valid instances of this
  57  * class are predefined, and no constructor is given for creating
  58  * new instances.
  59  *
  60  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  61  * @since 1.5
  62  */
  63 public final class SimpleType<T>
  64   extends OpenType<T>
  65 {
  66
  67   /**
  68    * The {@link SimpleType} representation of
  69    * <code>java.math.BigDecimal</code>.
  70    */
  71   public static final SimpleType<BigDecimal> BIGDECIMAL;
  72
  73   /**
  74    * The {@link SimpleType} representation of
  75    * <code>java.math.BigInteger</code>.
  76    */
  77   public static final SimpleType<BigInteger> BIGINTEGER;
  78
  79   /**
  80    * The {@link SimpleType} representation of
  81    * <code>java.lang.Boolean</code>.
  82    */
  83   public static final SimpleType<Boolean> BOOLEAN;
  84
  85   /**
  86    * The {@link SimpleType} representation of
  87    * <code>java.lang.Byte</code>.
  88    */
  89   public static final SimpleType<Byte> BYTE;
  90
  91   /**
  92    * The {@link SimpleType} representation of
  93    * <code>java.lang.Character</code>.
  94    */
  95   public static final SimpleType<Character> CHARACTER;
  96
  97   /**
  98    * The {@link SimpleType} representation of
  99    * <code>java.util.Date</code>.
 100    */
 101   public static final SimpleType<Date> DATE;
 102
 103   /**
 104    * The {@link SimpleType} representation of
 105    * <code>java.lang.Double</code>.
 106    */
 107   public static final SimpleType<Double> DOUBLE;
 108
 109   /**
 110    * The {@link SimpleType} representation of
 111    * <code>java.lang.Float</code>.
 112    */
 113   public static final SimpleType<Float> FLOAT;
 114
 115   /**
 116    * The {@link SimpleType} representation of
 117    * <code>java.lang.Integer</code>.
 118    */
 119   public static final SimpleType<Integer> INTEGER;
 120
 121   /**
 122    * The {@link SimpleType} representation of
 123    * <code>java.lang.Long</code>.
 124    */
 125   public static final SimpleType<Long> LONG;
 126
 127   /**
 128    * The {@link SimpleType} representation of
 129    * <code>javax.management.ObjectName</code>.
 130    */
 131   public static final SimpleType<ObjectName> OBJECTNAME;
 132
 133
 134   /**
 135    * The {@link SimpleType} representation of
 136    * <code>java.lang.Short</code>.
 137    */
 138   public static final SimpleType<Short> SHORT;
 139
 140   /**
 141    * The {@link SimpleType} representation of
 142    * <code>java.lang.String</code>.
 143    */
 144   public static final SimpleType<String> STRING;
 145
 146   /**
 147    * The {@link SimpleType} representation of
 148    * <code>java.lang.Void</code>.
 149    */
 150   public static final SimpleType<Void> VOID;
 151
 152   /**
 153    * Compatible with JDK 1.5
 154    */
 155   private static final long serialVersionUID = 2215577471957694503L;
 156
 157   /**
 158    * The hash code of this instance.
 159    */
 160   private transient Integer hashCode;
 161
 162   /**
 163    * The <code>toString()</code> result of this instance.
 164    */
 165   private transient String string;
 166
 167   /**
 168    * Static construction of the {@link SimpleType} instances.
 169    */
 170   static
 171   {
 172     try
 173       {
 174         BIGDECIMAL = new SimpleType<BigDecimal>("java.math.BigDecimal");
 175         BIGINTEGER = new SimpleType<BigInteger>("java.math.BigInteger");
 176         BOOLEAN = new SimpleType<Boolean>("java.lang.Boolean");
 177         BYTE = new SimpleType<Byte>("java.lang.Byte");
 178         CHARACTER = new SimpleType<Character>("java.lang.Character");
 179         DATE = new SimpleType<Date>("java.util.Date");
 180         DOUBLE = new SimpleType<Double>("java.lang.Double");
 181         FLOAT = new SimpleType<Float>("java.lang.Float");
 182         INTEGER = new SimpleType<Integer>("java.lang.Integer");
 183         LONG = new SimpleType<Long>("java.lang.Long");
 184         OBJECTNAME =
 185           new SimpleType<ObjectName>("javax.management.ObjectName");
 186         SHORT = new SimpleType<Short>("java.lang.Short");
 187         STRING = new SimpleType<String>("java.lang.String");
 188         VOID = new SimpleType<Void>("java.lang.Void");
 189       }
 190     catch (OpenDataException e)
 191       {
 192         /* In normal circumstances, this shouldn't be possible. */
 193         throw new IllegalStateException("A invalid class name " +
 194                                         "was passed to the SimpleType " +
 195                                         "constructor.", e);
 196       }
 197   }
 198
 199   /**
 200    * Constructs a new {@link SimpleType} instance for the given
 201    * class name.  The class name is also used as the type name
 202    * and description of the {@link OpenType} instance.
 203    *
 204    * @param name the name of the class this instance should
 205    *             represent.
 206    * @throws OpenDataException if somehow the constructor of the
 207    *                           superclass is passed an invalid
 208    *                           class name.
 209    */
 210   private SimpleType(String name)
 211     throws OpenDataException
 212   {
 213     super(name, name, name);
 214   }
 215
 216   /**
 217    * <p>
 218    * Compares this simple data type with another object
 219    * for equality.  The objects are judged to be equal if:
 220    * </p>
 221    * <ul>
 222    * <li><code>obj</code> is not null.</li>
 223    * <li><code>obj</code> is an instance of
 224    * {@link SimpleType}.</li>
 225    * <li>The class names are equal.</li>
 226    * </ul>
 227    *
 228    * @param obj the object to compare with.
 229    * @return true if the conditions above hold.
 230    */
 231   public boolean equals(Object obj)
 232   {
 233     if (!(obj instanceof SimpleType))
 234       return false;
 235     SimpleType<?> sType = (SimpleType<?>) obj;
 236     return sType.getClassName().equals(getClassName());
 237   }
 238
 239   /**
 240    * <p>
 241    * Returns the hash code of the simple data type.
 242    * This is simply the hash code of the class name,
 243    * which is the same element of the type compared
 244    * as part of the
 245    * {@link #equals(java.lang.Object)} method, thus ensuring
 246    * that the hashcode is compatible with the equality
 247    * test.
 248    * </p>
 249    * <p>
 250    * As instances of this class are immutable, the hash code
 251    * is computed just once for each instance and reused
 252    * throughout its life.
 253    * </p>
 254    *
 255    * @return the hash code of this instance.
 256    */
 257   public int hashCode()
 258   {
 259     if (hashCode == null)
 260       hashCode = Integer.valueOf(getClassName().hashCode());
 261     return hashCode.intValue();
 262   }
 263
 264   /**
 265    * Returns true if the specified object is a member of this
 266    * simple type.  The object is judged to be so if it is
 267    * non-null and its class name is the same as that returned
 268    * by {@link SimpleType#getClassName()}.
 269    *
 270    * @param obj the object to test for membership.
 271    * @return true if the object is a member of this type.
 272    */
 273   public boolean isValue(Object obj)
 274   {
 275     if (obj == null)
 276       return false;
 277     return obj.getClass().getName().equals(getClassName());
 278   }
 279
 280   /**
 281    * Replaces instances of this class read from an
 282    * {@link java.io.ObjectInputStream} with one of the predefined
 283    * values.  This ensures that each existing instance of
 284    * this class is one of these unique instances.
 285    *
 286    * @return the replacement object.
 287    * @throws ObjectStreamException if the object can not be
 288    *                               resolved.
 289    */
 290   public Object readResolve()
 291     throws ObjectStreamException
 292   {
 293     if (equals(BIGDECIMAL))
 294       return BIGDECIMAL;
 295     if (equals(BIGINTEGER))
 296       return BIGINTEGER;
 297     if (equals(BOOLEAN))
 298       return BOOLEAN;
 299     if (equals(BYTE))
 300       return BYTE;
 301     if (equals(CHARACTER))
 302       return CHARACTER;
 303     if (equals(DATE))
 304       return DATE;
 305     if (equals(DOUBLE))
 306       return DOUBLE;
 307     if (equals(FLOAT))
 308       return FLOAT;
 309     if (equals(INTEGER))
 310       return INTEGER;
 311     if (equals(LONG))
 312       return LONG;
 313     if (equals(OBJECTNAME))
 314       return OBJECTNAME;
 315     if (equals(SHORT))
 316       return SHORT;
 317     if (equals(STRING))
 318       return STRING;
 319     if (equals(VOID))
 320       return VOID;
 321     throw new InvalidObjectException("Invalid simple type instance " +
 322                                      "deserialized.");
 323   }
 324
 325   /**
 326    * <p>
 327    * Returns a textual representation of this instance.  This
 328    * is constructed using the class name
 329    * (<code>javax.management.openmbean.SimpleType</code>)
 330    * and the name of the class the type represents.
 331    * </p>
 332    * <p>
 333    * As instances of this class are immutable, the return value
 334    * is computed just once for each instance and reused
 335    * throughout its life.
 336    * </p>
 337    *
 338    * @return a @link{java.lang.String} instance representing
 339    *         the instance in textual form.
 340    */
 341   public String toString()
 342   {
 343     if (string == null)
 344       string = getClass().getName()
 345         + "[name=" + getClassName()
 346         + "]";
 347     return string;
 348   }
 349
 350 }