Constructs a {@code CompositeDataSupport} instance with the specified + * {@code compositeType}, whose item values + * are specified by {@code itemValues[]}, in the same order as in + * {@code itemNames[]}. + * As a {@code CompositeType} does not specify any order on its items, + * the {@code itemNames[]} parameter is used + * to specify the order in which the values are given in {@code itemValues[]}. + * The items contained in this {@code CompositeDataSupport} instance are + * internally stored in a {@code TreeMap}, + * thus sorted in ascending lexicographic order of their names, for faster + * retrieval of individual item values.
+ * + *The constructor checks that all the constraints listed below for each + * parameter are satisfied, + * and throws the appropriate exception if they are not.
+ * + * @param compositeType the composite type of this composite + * data instance; must not be null. + * + * @param itemNames {@code itemNames} must list, in any order, all the + * item names defined in {@code compositeType}; the order in which the + * names are listed, is used to match values in {@code itemValues[]}; must + * not be null or empty. + * + * @param itemValues the values of the items, listed in the same order as + * their respective names in {@code itemNames}; each item value can be + * null, but if it is non-null it must be a valid value for the open type + * defined in {@code compositeType} for the corresponding item; must be of + * the same size as {@code itemNames}; must not be null or empty. + * + * @throws IllegalArgumentException {@code compositeType} is null, or + * {@code itemNames[]} or {@code itemValues[]} is null or empty, or one + * of the elements in {@code itemNames[]} is a null or empty string, or + * {@code itemNames[]} and {@code itemValues[]} are not of the same size. + * + * @throws OpenDataException {@code itemNames[]} or + * {@code itemValues[]}'s size differs from the number of items defined in + * {@code compositeType}, or one of the elements in {@code itemNames[]} + * does not exist as an item name defined in {@code compositeType}, or one + * of the elements in {@code itemValues[]} is not a valid value for the + * corresponding item as defined in {@code compositeType}. + */ + public CompositeDataSupport( + CompositeType compositeType, String[] itemNames, Object[] itemValues) + throws OpenDataException { + this(makeMap(itemNames, itemValues), compositeType); + } + + private static SortedMap
+ * Constructs a {@code CompositeDataSupport} instance with the specified {@code compositeType},
+ * whose item names and corresponding values
+ * are given by the mappings in the map {@code items}.
+ * This constructor converts the keys to a string array and the values to an object array and calls
+ * {@code CompositeDataSupport(javax.management.openmbean.CompositeType, java.lang.String[], java.lang.Object[])}.
+ *
+ * @param compositeType the composite type of this composite data instance;
+ * must not be null.
+ * @param items the mappings of all the item names to their values;
+ * {@code items} must contain all the item names defined in {@code compositeType};
+ * must not be null or empty.
+ *
+ * @throws IllegalArgumentException {@code compositeType} is null, or
+ * {@code items} is null or empty, or one of the keys in {@code items} is a null
+ * or empty string.
+ * @throws OpenDataException {@code items}' size differs from the
+ * number of items defined in {@code compositeType}, or one of the
+ * keys in {@code items} does not exist as an item name defined in
+ * {@code compositeType}, or one of the values in {@code items}
+ * is not a valid value for the corresponding item as defined in
+ * {@code compositeType}.
+ * @throws ArrayStoreException one or more keys in {@code items} is not of
+ * the class {@code java.lang.String}.
+ */
+ public CompositeDataSupport(CompositeType compositeType,
+ Map
+ * Returns {@code true} if and only if all of the following statements are true:
+ *
+ * This ensures that this {@code equals} method works properly for
+ * obj parameters which are different implementations of the
+ *
+ * The hash code of a
+ * This ensures that
+ * Each item value's hash code is added to the returned hash code.
+ * If an item value is an array,
+ * its hash code is obtained as if by calling the
+ * {@link java.util.Arrays#deepHashCode(Object[]) deepHashCode} method
+ * for arrays of object reference types or the appropriate overloading
+ * of {@code Arrays.hashCode(e)} for arrays of primitive types.
+ *
+ * @return the hash code value for this
+ * The string representation consists of the name of this class (ie CompositeDataSupport
instance for equality.
+ *
+ *
+ * CompositeData
interface,CompositeData
interface, with the restrictions mentioned in the
+ * {@link java.util.Collection#equals(Object) equals}
+ * method of the {@code java.util.Collection} interface.
+ *
+ * @param obj the object to be compared for equality with this
+ * CompositeDataSupport
instance.
+ * @return true
if the specified object is equal to this
+ * CompositeDataSupport
instance.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+
+ // if obj is not a CompositeData, return false
+ if (!(obj instanceof CompositeData)) {
+ return false;
+ }
+
+ CompositeData other = (CompositeData) obj;
+
+ // their compositeType should be equal
+ if (!this.getCompositeType().equals(other.getCompositeType()) ) {
+ return false;
+ }
+
+ if (contents.size() != other.values().size()) {
+ return false;
+ }
+
+ for (Map.EntryCompositeDataSupport
instance.
+ * CompositeDataSupport
instance is the sum of the hash codes
+ * of all elements of information used in equals
comparisons
+ * (ie: its composite type and all the item values).
+ * t1.equals(t2)
implies that t1.hashCode()==t2.hashCode()
+ * for any two CompositeDataSupport
instances t1
and t2
,
+ * as required by the general contract of the method
+ * {@link Object#hashCode() Object.hashCode()}.
+ * CompositeDataSupport
instance
+ */
+ @Override
+ public int hashCode() {
+ int hashcode = compositeType.hashCode();
+
+ for (Object o : contents.values()) {
+ if (o instanceof Object[])
+ hashcode += Arrays.deepHashCode((Object[]) o);
+ else if (o instanceof byte[])
+ hashcode += Arrays.hashCode((byte[]) o);
+ else if (o instanceof short[])
+ hashcode += Arrays.hashCode((short[]) o);
+ else if (o instanceof int[])
+ hashcode += Arrays.hashCode((int[]) o);
+ else if (o instanceof long[])
+ hashcode += Arrays.hashCode((long[]) o);
+ else if (o instanceof char[])
+ hashcode += Arrays.hashCode((char[]) o);
+ else if (o instanceof float[])
+ hashcode += Arrays.hashCode((float[]) o);
+ else if (o instanceof double[])
+ hashcode += Arrays.hashCode((double[]) o);
+ else if (o instanceof boolean[])
+ hashcode += Arrays.hashCode((boolean[]) o);
+ else if (o != null)
+ hashcode += o.hashCode();
+ }
+
+ return hashcode;
+ }
+
+ /**
+ * Returns a string representation of this CompositeDataSupport
instance.
+ * javax.management.openmbean.CompositeDataSupport
),
+ * the string representation of the composite type of this instance, and the string representation of the contents
+ * (ie list the itemName=itemValue mappings).
+ *
+ * @return a string representation of this CompositeDataSupport
instance
+ */
+ @Override
+ public String toString() {
+ return new StringBuilder()
+ .append(this.getClass().getName())
+ .append("(compositeType=")
+ .append(compositeType.toString())
+ .append(",contents=")
+ .append(contentString())
+ .append(")")
+ .toString();
+ }
+
+ private String contentString() {
+ StringBuilder sb = new StringBuilder("{");
+ String sep = "";
+ for (Map.Entry