javax.management.openmbean
public class CompositeDataSupport extends Object implements CompositeData, Serializable
Since: 1.5
| Constructor Summary | |
|---|---|
| CompositeDataSupport(CompositeType type, Map<String,?> items)
Constructs a new {@link CompositeDataSupport} instance with the
specified type using field names and values from the supplied map.
| |
| CompositeDataSupport(CompositeType type, String[] names, Object[] values)
Constructs a new {@link CompositeDataSupport} instance with the
specified type using the supplied arrays of field names and
values. | |
| Method Summary | |
|---|---|
| boolean | containsKey(String key)
Returns true if this {@link CompositeData} instance contains
the specified key. |
| boolean | containsValue(Object value)
Returns true if this {@link CompositeData} instance has
a value equal to that supplied.
|
| boolean | equals(Object obj)
Compares the specified object with this object for equality.
|
| Object | get(String key)
Retrieves the value for the specified key.
|
| Object[] | getAll(String[] keys)
Returns the appropriate value for each key in the given array,
using the same ordering.
|
| CompositeType | getCompositeType()
Returns the composite type which corresponds to this instance
of {@link CompositeData}.
|
| int | hashCode()
Returns the hash code of this instance. |
| String | toString()
Returns a textual representation of this instance. |
| Collection<?> | values()
Returns a read-only collection of the values associated with
this instance. |
Parameters: type the composite type of this composite data structure. items a mapping of field names to values. This should match the mappings given by the type (i.e. for each mapping in the type, there should be a corresponding field name with a value of the correct type).
Throws: IllegalArgumentException if the type, the map or any of the keys
or values in the map are null,
or if any key from the map is an empty
string. OpenDataException if a mismatch occurs between the map and the
field name/type specification given by the
{@link CompositeType} instance. This may be
due to the two having a different size, a
mismatch between keys or an incorrectly typed
value. ArrayStoreException if one of the keys is not a
{@link java.lang.String} (thus calling a failure
in converting the keys to an array of strings).
null. The {@link java.lang.String}s
within the names array must be non-empty. The
arrays must match in size and order, as each element of the
names array is matched against the corresponding
value in the values array. Internally, the two are
stored in a map, lexographically ordered using the field names.
The data given should also conform to the description of the
instance given by the {@link CompositeType} instance supplied.
Parameters: type the composite type of this composite data structure. names the field names. values the corresponding values of the fields.
Throws: IllegalArgumentException if the type, the arrays or any of the keys
or values in the arrays are null,
or if any key from names is
an empty string. This also occurs if the
arrays differ in length. OpenDataException if a mismatch occurs between the arrays and the
field name/type specification given by the
{@link CompositeType} instance. This may be
due to a differing number of field names, a
mismatch between names or an incorrectly typed
value.
null or the empty string.
Parameters: key the key to find in the structure.
Returns: true if the key exists.
Parameters: value the value to look for.
Returns: true if the value exists.
Parameters: obj the object to compare for equality.
Returns: true if obj is equal to this.
Parameters: key the key whose value should be returned.
Returns: the matching value.
Throws: IllegalArgumentException if the key is null
or the empty string. InvalidKeyException if the key does not exist.
Parameters: keys the keys whose values should be returned.
Returns: the matching values.
Throws: IllegalArgumentException if one of the keys is
null or the
empty string. InvalidKeyException if one of the keys does not exist.
Returns: the composite type for this instance.
e1.equals(e2) implies
e1.hashCode() == e2.hashCode(), holds for any pair
of instances, e1 and e2. However,
this relies on the other instance implementing the
hashCode method correctly, if it is not an
instance of {@link CompositeDataSupport}.
Returns: the hash code of this {@link CompositeData}.
See Also: equals
key=value for each pair of key and value.
Returns: a {@link java.lang.String} representation of the object.
Returns: the values of this instance.