1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
/* * @(#)MBeanNotificationInfo.java 1.37 06/03/15 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.management; import java.util.Arrays; /** * <p>The <CODE>MBeanNotificationInfo</CODE> class is used to describe the * characteristics of the different notification instances * emitted by an MBean, for a given Java class of notification. * If an MBean emits notifications that can be instances of different Java classes, * then the metadata for that MBean should provide an <CODE>MBeanNotificationInfo</CODE> * object for each of these notification Java classes.</p> * * <p>Instances of this class are immutable. Subclasses may be * mutable but this is not recommended.</p> * * <p>This class extends <CODE>javax.management.MBeanFeatureInfo</CODE> * and thus provides <CODE>name</CODE> and <CODE>description</CODE> fields. * The <CODE>name</CODE> field should be the fully qualified Java class name of * the notification objects described by this class.</p> * * <p>The <CODE>getNotifTypes</CODE> method returns an array of * strings containing the notification types that the MBean may * emit. The notification type is a dot-notation string which * describes what the emitted notification is about, not the Java * class of the notification. A single generic notification class can * be used to send notifications of several types. All of these types * are returned in the string array result of the * <CODE>getNotifTypes</CODE> method. * * @since 1.5 */ public class MBeanNotificationInfo extends MBeanFeatureInfo implements Cloneable { /* Serial version */ static final long serialVersionUID = -3888371564530107064L; private static final String[] NO_TYPES = new String[0]; static final MBeanNotificationInfo[] NO_NOTIFICATIONS = new MBeanNotificationInfo[0]; /** * @serial The different types of the notification. */ private final String[] types; /** @see MBeanInfo#arrayGettersSafe */ private final transient boolean arrayGettersSafe; /** * Constructs an <CODE>MBeanNotificationInfo</CODE> object. * * @param notifTypes The array of strings (in dot notation) * containing the notification types that the MBean may emit. * This may be null with the same effect as a zero-length array. * @param name The fully qualified Java class name of the * described notifications. * @param description A human readable description of the data. */ public MBeanNotificationInfo(String[] notifTypes, String name, String description) { this(notifTypes, name, description, null); } /** * Constructs an <CODE>MBeanNotificationInfo</CODE> object. * * @param notifTypes The array of strings (in dot notation) * containing the notification types that the MBean may emit. * This may be null with the same effect as a zero-length array. * @param name The fully qualified Java class name of the * described notifications. * @param description A human readable description of the data. * @param descriptor The descriptor for the notifications. This may be null * which is equivalent to an empty descriptor. * * @since 1.6 */ public MBeanNotificationInfo(String[] notifTypes, String name, String description, Descriptor descriptor) { super(name, description, descriptor); /* We do not validate the notifTypes, since the spec just says they are dot-separated, not that they must look like Java classes. E.g. the spec doesn't forbid "sun.prob.25" as a notifType, though it doesn't explicitly allow it either. */ if (notifTypes == null) notifTypes = NO_TYPES; this.types = notifTypes; this.arrayGettersSafe = MBeanInfo.arrayGettersSafe(this.getClass(), MBeanNotificationInfo.class); } /** * Returns a shallow clone of this instance. * The clone is obtained by simply calling <tt>super.clone()</tt>, * thus calling the default native shallow cloning mechanism * implemented by <tt>Object.clone()</tt>. * No deeper cloning of any internal field is made. */ public Object clone () { try { return super.clone() ; } catch (CloneNotSupportedException e) { // should not happen as this class is cloneable return null; } } /** * Returns the array of strings (in dot notation) containing the * notification types that the MBean may emit. * * @return the array of strings. Changing the returned array has no * effect on this MBeanNotificationInfo. */ public String[] getNotifTypes() { if (types.length == 0) return NO_TYPES; else return (String[]) types.clone(); } private String[] fastGetNotifTypes() { if (arrayGettersSafe) return types; else return getNotifTypes(); } public String toString() { return getClass().getName() + "[" + "description=" + getDescription() + ", " + "name=" + getName() + ", " + "notifTypes=" + Arrays.asList(fastGetNotifTypes()) + ", " + "descriptor=" + getDescriptor() + "]"; } /** * Compare this MBeanNotificationInfo to another. * * @param o the object to compare to. * * @return true if and only if <code>o</code> is an MBeanNotificationInfo * such that its {@link #getName()}, {@link #getDescription()}, * {@link #getDescriptor()}, * and {@link #getNotifTypes()} values are equal (not necessarily * identical) to those of this MBeanNotificationInfo. Two * notification type arrays are equal if their corresponding * elements are equal. They are not equal if they have the same * elements but in a different order. */ public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof MBeanNotificationInfo)) return false; MBeanNotificationInfo p = (MBeanNotificationInfo) o; return (p.getName().equals(getName()) && p.getDescription().equals(getDescription()) && p.getDescriptor().equals(getDescriptor()) && Arrays.equals(p.fastGetNotifTypes(), fastGetNotifTypes())); } public int hashCode() { int hash = getName().hashCode(); for (int i = 0; i < types.length; i++) hash ^= types[i].hashCode(); return hash; } }