OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [management/] [openmbean/] [OpenMBeanParameterInfoSupport.java] - Blame information for rev 772

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 772 jeremybenn
/* OpenMBeanParameterInfoSupport.java -- Open typed info about a parameter.
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.util.Collections;
41
import java.util.HashSet;
42
import java.util.Set;
43
 
44
import javax.management.MBeanParameterInfo;
45
 
46
/**
47
 * Describes the parameters of a constructor or operation associated
48
 * with an open management bean.
49
 *
50
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
51
 * @since 1.5
52
 */
53
public class OpenMBeanParameterInfoSupport
54
  extends MBeanParameterInfo
55
  implements OpenMBeanParameterInfo
56
{
57
 
58
  /**
59
   * Compatible with JDK 1.5
60
   */
61
  private static final long serialVersionUID = -7235016873758443122L;
62
 
63
  /**
64
   * The open type of the parameter.
65
   */
66
  private OpenType<?> openType;
67
 
68
  /**
69
   * The default value of the parameter (may be <code>null</code>).
70
   */
71
  private Object defaultValue;
72
 
73
  /**
74
   * The possible legal values of the parameter (may be <code>null</code>).
75
   */
76
  private Set<?> legalValues;
77
 
78
  /**
79
   * The minimum value of the parameter (may be <code>null</code>).
80
   */
81
  private Comparable<?> minValue;
82
 
83
  /**
84
   * The maximum value of the parameter (may be <code>null</code>).
85
   */
86
  private Comparable<?> maxValue;
87
 
88
  /**
89
   * The hash code of this instance.
90
   */
91
  private transient Integer hashCode;
92
 
93
  /**
94
   * The <code>toString()</code> result of this instance.
95
   */
96
  private transient String string;
97
 
98
  /**
99
   * Constructs a new {@link OpenMBeanParameterInfo} using the specified
100
   * name, description and open type.  None of these values may be
101
   * <code>null</code> and the name and description may not be equal
102
   * to the empty string.
103
   *
104
   * @param name the name of the parameter.
105
   * @param desc a description of the parameter.
106
   * @param type the open type of the parameter.
107
   * @throws IllegalArgumentException if the name, description or
108
   *                                  open type are <code>null</code>
109
   *                                  or the name or description are
110
   *                                  the empty string.
111
   */
112
  public OpenMBeanParameterInfoSupport(String name, String desc, OpenType<?> type)
113
  {
114
    super(name, type == null ? null : type.getClassName(), desc);
115
    if (name == null)
116
      throw new IllegalArgumentException("The name may not be null.");
117
    if (desc == null)
118
      throw new IllegalArgumentException("The description may not be null.");
119
    if (type == null)
120
      throw new IllegalArgumentException("The type may not be null.");
121
    if (name.length() == 0)
122
      throw new IllegalArgumentException("The name may not be the empty string.");
123
    if (desc.length() == 0)
124
      throw new IllegalArgumentException("The description may not be the " +
125
                                         "empty string.");
126
    openType = type;
127
  }
128
 
129
  /**
130
   * Constructs a new {@link OpenMBeanParameterInfo} using the
131
   * specified name, description, open type and default value.  The
132
   * name, description and open type cannot be <code>null</code> and
133
   * the name and description may not be equal to the empty string.
134
   * The default value may be <code>null</code>.  If non-null, it must
135
   * be a valid value of the given open type.  Default values are not
136
   * applicable to the open types, {@link ArrayType} and {@link
137
   * TabularType}.
138
   *
139
   * @param name the name of the parameter.
140
   * @param desc a description of the parameter.
141
   * @param type the open type of the parameter.
142
   * @param defaultValue the default value of the parameter.
143
   * @throws IllegalArgumentException if the name, description or
144
   *                                  open type are <code>null</code>
145
   *                                  or the name or description are
146
   *                                  the empty string.
147
   * @throws OpenDataException if <code>defaultValue<code> is non-null
148
   *                           and is either not a value of the given
149
   *                           open type or the open type is an instance
150
   *                           of {@link ArrayType} or {@link TabularType}.
151
   */
152
  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
153
                                           T defaultValue)
154
    throws OpenDataException
155
  {
156
    this(name, desc, type, defaultValue, null);
157
  }
158
 
159
  /**
160
   * <p>
161
   * Constructs a new {@link OpenMBeanParameterInfo} using the
162
   * specified name, description, open type, default, maximum and
163
   * minimum values.  The name, description and open type cannot be
164
   * <code>null</code> and the name and description may not be equal
165
   * to the empty string.  The default, maximum and minimum values may
166
   * be <code>null</code>.  The following conditions apply when the
167
   * parameters mentioned are non-null:
168
   * </p>
169
   * <ul>
170
   * <li>The values must be valid values for the given open type.</li>
171
   * <li>Default values are not applicable to the open types, {@link
172
   * ArrayType} and {@link TabularType}.</li>
173
   * <li>The minimum value must be smaller than or equal to the maximum value
174
   * (literally, <code>minValue.compareTo(maxValue) <= 0</code>.</li>
175
   * <li>The minimum value must be smaller than or equal to the default value
176
   * (literally, <code>minValue.compareTo(defaultValue) <= 0</code>.</li>
177
   * <li>The default value must be smaller than or equal to the maximum value
178
   * (literally, <code>defaultValue.compareTo(maxValue) <= 0</code>.</li>
179
   * </ul>
180
   *
181
   * @param name the name of the parameter.
182
   * @param desc a description of the parameter.
183
   * @param type the open type of the parameter.
184
   * @param defaultValue the default value of the parameter, or <code>null</code>.
185
   * @param minimumValue the minimum value of the parameter, or <code>null</code>.
186
   * @param maximumValue the maximum value of the parameter, or <code>null</code>.
187
   * @throws IllegalArgumentException if the name, description or
188
   *                                  open type are <code>null</code>
189
   *                                  or the name or description are
190
   *                                  the empty string.
191
   * @throws OpenDataException if any condition in the list above is broken.
192
   */
193
  @SuppressWarnings("unchecked")
194
  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
195
                                           T defaultValue, Comparable<T> minimumValue,
196
                                           Comparable<T> maximumValue)
197
    throws OpenDataException
198
  {
199
    this(name, desc, type);
200
    if (defaultValue != null && !(type.isValue(defaultValue)))
201
      throw new OpenDataException("The default value is not a member of the " +
202
                                  "open type given.");
203
    if (minimumValue != null && !(type.isValue(minimumValue)))
204
      throw new OpenDataException("The minimum value is not a member of the " +
205
                                  "open type given.");
206
    if (maximumValue != null && !(type.isValue(maximumValue)))
207
      throw new OpenDataException("The maximum value is not a member of the " +
208
                                  "open type given.");
209
    if (defaultValue != null && (type instanceof ArrayType ||
210
                                 type instanceof TabularType))
211
      throw new OpenDataException("Default values are not applicable for " +
212
                                  "array or tabular types.");
213
    if (minimumValue != null && maximumValue != null
214
        && minimumValue.compareTo((T) maximumValue) > 0)
215
      throw new OpenDataException("The minimum value is greater than the " +
216
                                  "maximum.");
217
    if (minimumValue != null && defaultValue != null
218
        && minimumValue.compareTo(defaultValue) > 0)
219
      throw new OpenDataException("The minimum value is greater than the " +
220
                                  "default.");
221
    if (defaultValue != null && maximumValue != null
222
        && maximumValue.compareTo(defaultValue) < 0)
223
      throw new OpenDataException("The default value is greater than the " +
224
                                  "maximum.");
225
 
226
    this.defaultValue = defaultValue;
227
    minValue = minimumValue;
228
    maxValue = maximumValue;
229
  }
230
 
231
  /**
232
   * <p>
233
   * Constructs a new {@link OpenMBeanParameterInfo} using the
234
   * specified name, description, open type, default value and
235
   * set of legal values.  The name, description and open type cannot be
236
   * <code>null</code> and the name and description may not be equal
237
   * to the empty string.  The default, maximum and minimum values may
238
   * be <code>null</code>.  The following conditions apply when the
239
   * parameters mentioned are non-null:
240
   * </p>
241
   * <ul>
242
   * <li>The default value and each of the legal values must be a valid
243
   * value for the given open type.</li>
244
   * <li>Default and legal values are not applicable to the open types, {@link
245
   * ArrayType} and {@link TabularType}.</li>
246
   * <li>The default value is not in the set of legal values.</li>
247
   * </ul>
248
   * <p>
249
   * The legal values are copied from the array into a unmodifiable set,
250
   * so future modifications to the array have no effect.
251
   * </p>
252
   *
253
   * @param name the name of the parameter.
254
   * @param desc a description of the parameter.
255
   * @param type the open type of the parameter.
256
   * @param defaultValue the default value of the parameter, or <code>null</code>.
257
   * @param legalValues the legal values of the parameter.  May be
258
   *                    <code>null</code> or an empty array.
259
   * @throws IllegalArgumentException if the name, description or
260
   *                                  open type are <code>null</code>
261
   *                                  or the name or description are
262
   *                                  the empty string.
263
   * @throws OpenDataException if any condition in the list above is broken.
264
   */
265
  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
266
                                           T defaultValue, T[] legalValues)
267
    throws OpenDataException
268
  {
269
    this(name, desc, type);
270
    if (defaultValue != null && !(type.isValue(defaultValue)))
271
      throw new OpenDataException("The default value is not a member of the " +
272
                                  "open type given.");
273
    if (defaultValue != null && (type instanceof ArrayType ||
274
                                 type instanceof TabularType))
275
      throw new OpenDataException("Default values are not applicable for " +
276
                                  "array or tabular types.");
277
    if (legalValues != null && (type instanceof ArrayType ||
278
                                type instanceof TabularType))
279
      throw new OpenDataException("Legal values are not applicable for " +
280
                                  "array or tabular types.");
281
    if (legalValues != null && legalValues.length > 0)
282
      {
283
        Set<T> lv = new HashSet<T>(legalValues.length);
284
        for (int a = 0; a < legalValues.length; ++a)
285
          {
286
            if (legalValues[a] != null &&
287
                !(type.isValue(legalValues[a])))
288
              throw new OpenDataException("The legal value, "
289
                                          + legalValues[a] +
290
                                          "is not a member of the " +
291
                                          "open type given.");
292
            lv.add(legalValues[a]);
293
          }
294
        if (defaultValue != null && !(lv.contains(defaultValue)))
295
          throw new OpenDataException("The default value is not in the set " +
296
                                      "of legal values.");
297
        this.legalValues = Collections.unmodifiableSet(lv);
298
      }
299
    this.defaultValue = defaultValue;
300
  }
301
 
302
  /**
303
   * Compares this parameter with the supplied object.  This returns
304
   * true iff the object is an instance of {@link OpenMBeanParameterInfo}
305
   * with an equal name and open type and the same default, minimum,
306
   * maximum and legal values.
307
   *
308
   * @param obj the object to compare.
309
   * @return true if the object is a {@link OpenMBeanParameterInfo}
310
   *         instance,
311
   *         <code>name.equals(object.getName())</code>,
312
   *         <code>openType.equals(object.getOpenType())</code>,
313
   *         <code>defaultValue.equals(object.getDefaultValue())</code>,
314
   *         <code>minValue.equals(object.getMinValue())</code>,
315
   *         <code>maxValue.equals(object.getMaxValue())</code>,
316
   *         and <code>legalValues.equals(object.getLegalValues())</code>.
317
   */
318
  public boolean equals(Object obj)
319
  {
320
    if (!(obj instanceof OpenMBeanParameterInfo))
321
      return false;
322
    OpenMBeanParameterInfo o = (OpenMBeanParameterInfo) obj;
323
    return getName().equals(o.getName()) &&
324
      openType.equals(o.getOpenType()) &&
325
      (defaultValue == null ? o.getDefaultValue() == null :
326
       defaultValue.equals(o.getDefaultValue())) &&
327
      (minValue == null ? o.getMinValue() == null :
328
       minValue.equals(o.getMinValue())) &&
329
      (maxValue == null ? o.getMaxValue() == null :
330
       maxValue.equals(o.getMaxValue())) &&
331
      (legalValues == null ? o.getLegalValues() == null :
332
       legalValues.equals(o.getLegalValues()));
333
  }
334
 
335
  /**
336
   * Returns the default value of this parameter, or <code>null</code>
337
   * if there is no default value.
338
   *
339
   * @return the default value of the parameter, or <code>null</code>
340
   *         if there is no default.
341
   */
342
  public Object getDefaultValue()
343
  {
344
    return defaultValue;
345
  }
346
 
347
  /**
348
   * Returns a {@link java.util.Set} enumerating the legal values
349
   * of this parameter, or <code>null</code> if no such limited
350
   * set exists for this parameter.
351
   *
352
   * @return a set of legal values, or <code>null</code> if no such
353
   *         set exists.
354
   */
355
  public Set<?> getLegalValues()
356
  {
357
    return legalValues;
358
  }
359
 
360
  /**
361
   * Returns the maximum value of this parameter, or <code>null</code>
362
   * if there is no maximum.
363
   *
364
   * @return the maximum value, or <code>null</code> if none exists.
365
   */
366
  public Comparable<?> getMaxValue()
367
  {
368
    return maxValue;
369
  }
370
 
371
  /**
372
   * Returns the minimum value of this parameter, or <code>null</code>
373
   * if there is no minimum.
374
   *
375
   * @return the minimum value, or <code>null</code> if none exists.
376
   */
377
  public Comparable<?> getMinValue()
378
  {
379
    return minValue;
380
  }
381
 
382
  /**
383
   * Returns the open type instance which represents the type of this
384
   * parameter.
385
   *
386
   * @return the open type of this parameter.
387
   */
388
  public OpenType<?> getOpenType()
389
  {
390
    return openType;
391
  }
392
 
393
  /**
394
   * Returns true if this parameter has a default value
395
   * (i.e. the value is non-null).
396
   *
397
   * @return true if this parameter has a default.
398
   */
399
  public boolean hasDefaultValue()
400
  {
401
    return defaultValue != null;
402
  }
403
 
404
  /**
405
   * <p>
406
   * Returns the hashcode of the parameter information as the sum of
407
   * the hashcodes of the name, open type, default value, maximum
408
   * value, minimum value and the set of legal values.
409
   * </p>
410
   * <p>
411
   * As instances of this class are immutable, the hash code
412
   * is computed just once for each instance and reused
413
   * throughout its life.
414
   * </p>
415
   *
416
   * @return the hashcode of the parameter information.
417
   */
418
  public int hashCode()
419
  {
420
    if (hashCode == null)
421
      hashCode = Integer.valueOf(getName().hashCode() +
422
                                 openType.hashCode() +
423
                                 (defaultValue == null ? 0 :
424
                                  defaultValue.hashCode()) +
425
                                 (minValue == null ? 0 :
426
                                  minValue.hashCode()) +
427
                                 (maxValue == null ? 0 :
428
                                  maxValue.hashCode()) +
429
                                 (legalValues == null ? 0 :
430
                                  legalValues.hashCode()));
431
    return hashCode.intValue();
432
  }
433
 
434
  /**
435
   * Returns true if there is a set of legal values for this
436
   * parameter (i.e. the value is non-null).
437
   *
438
   * @return true if a set of legal values exists for this
439
   *         parameter.
440
   */
441
  public boolean hasLegalValues()
442
  {
443
    return legalValues != null;
444
  }
445
 
446
  /**
447
   * Returns true if there is a maximum value for this parameter
448
   * (i.e. the value is non-null).
449
   *
450
   * @return true if a maximum value exists for this parameter.
451
   */
452
  public boolean hasMaxValue()
453
  {
454
    return maxValue != null;
455
  }
456
 
457
  /**
458
   * Returns true if there is a minimum value for this parameter.
459
   * (i.e. the value is non-null).
460
   *
461
   * @return true if a minimum value exists for this parameter.
462
   */
463
  public boolean hasMinValue()
464
  {
465
    return minValue != null;
466
  }
467
 
468
  /**
469
   * Returns true if the specified object is a valid value for
470
   * this parameter.
471
   *
472
   * @param obj the object to test.
473
   * @return true if <code>obj</code> is a valid value for this
474
   *         parameter.
475
   */
476
  public boolean isValue(Object obj)
477
  {
478
    return openType.isValue(obj);
479
  }
480
 
481
  /**
482
   * <p>
483
   * Returns a textual representation of this instance.  This
484
   * is constructed using the class name
485
   * (<code>javax.management.openmbean.OpenMBeanParameterInfo</code>)
486
   * along with the name, open type, default, minimum, maximum
487
   * and legal values of the parameter.
488
   * </p>
489
   * <p>
490
   * As instances of this class are immutable, the return value
491
   * is computed just once for each instance and reused
492
   * throughout its life.
493
   * </p>
494
   *
495
   * @return a @link{java.lang.String} instance representing
496
   *         the instance in textual form.
497
   */
498
  public String toString()
499
  {
500
    if (string == null)
501
      string = getClass().getName()
502
        + "[name=" + getName()
503
        + ",openType=" + openType
504
        + ",defaultValue=" + defaultValue
505
        + ",minValue=" + minValue
506
        + ",maxValue=" + maxValue
507
        + ",legalValues=" + legalValues
508
        + "]";
509
    return string;
510
  }
511
 
512
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.