001 /* SimpleType.java -- Open type descriptor for the base types.
002 Copyright (C) 2006, 2007 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package javax.management.openmbean;
039
040 import java.io.InvalidObjectException;
041 import java.io.ObjectStreamException;
042
043 import java.math.BigDecimal;
044 import java.math.BigInteger;
045
046 import java.util.Date;
047
048 import javax.management.ObjectName;
049
050 /**
051 * The open type descriptor for data values that are members
052 * of one of the simple types (such as an integer or a string).
053 * The other open types ({@link ArrayType}, {@link CompositeType},
054 * {@link TabularType}) are constructed from one or more of these
055 * types. The simple types are formed from a small subset of
056 * basic Java types. As a result, the valid instances of this
057 * class are predefined, and no constructor is given for creating
058 * new instances.
059 *
060 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
061 * @since 1.5
062 */
063 public final class SimpleType<T>
064 extends OpenType<T>
065 {
066
067 /**
068 * The {@link SimpleType} representation of
069 * <code>java.math.BigDecimal</code>.
070 */
071 public static final SimpleType<BigDecimal> BIGDECIMAL;
072
073 /**
074 * The {@link SimpleType} representation of
075 * <code>java.math.BigInteger</code>.
076 */
077 public static final SimpleType<BigInteger> BIGINTEGER;
078
079 /**
080 * The {@link SimpleType} representation of
081 * <code>java.lang.Boolean</code>.
082 */
083 public static final SimpleType<Boolean> BOOLEAN;
084
085 /**
086 * The {@link SimpleType} representation of
087 * <code>java.lang.Byte</code>.
088 */
089 public static final SimpleType<Byte> BYTE;
090
091 /**
092 * The {@link SimpleType} representation of
093 * <code>java.lang.Character</code>.
094 */
095 public static final SimpleType<Character> CHARACTER;
096
097 /**
098 * The {@link SimpleType} representation of
099 * <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 }