This adds the final class to javax.management.openmbean, TabularDataSupport.
Changelog:
2006-08-04 Andrew John Hughes <[EMAIL PROTECTED]>
* javax/management/openmbean/TabularData.java:
Documentation corrections.
* javax/management/openmbean/TabularDataSupport.java:
New file.
--
Andrew :-)
Escape the Java Trap with GNU Classpath!
http://www.gnu.org/philosophy/java-trap.html
public class gcj extends Freedom implements Java { ... }
Index: javax/management/openmbean/TabularData.java
===================================================================
RCS file:
/cvsroot/classpath/classpath/javax/management/openmbean/TabularData.java,v
retrieving revision 1.1
diff -u -3 -p -u -r1.1 TabularData.java
--- javax/management/openmbean/TabularData.java 9 Jul 2006 13:56:22 -0000
1.1
+++ javax/management/openmbean/TabularData.java 4 Aug 2006 21:29:15 -0000
@@ -55,12 +55,14 @@ public interface TabularData
/**
* Calculates the index the specified [EMAIL PROTECTED] CompositeData} value
* would have, if it was to be added to this [EMAIL PROTECTED] TabularData}
- * instance. This method includes a check that the type of
- * the given value is the same as the row type of this instance,
- * but not a check for existing instances of the given value.
- * The value must also not be <code>null</code>. Possible indices
- * are returned by the [EMAIL PROTECTED] TabularType#getIndexNames()} method
- * of this instance's tabular type.
+ * instance. This method includes a check that the type of the
+ * given value is the same as the row type of this instance, but not
+ * a check for existing instances of the given value. The value
+ * must also not be <code>null</code>. Possible indices are
+ * returned by the [EMAIL PROTECTED] TabularType#getIndexNames()} method of
+ * this instance's tabular type. The returned indices are the
+ * values of the fields in the supplied [EMAIL PROTECTED] CompositeData}
+ * instance that match the names given in the [EMAIL PROTECTED] TabularType}.
*
* @param val the [EMAIL PROTECTED] CompositeData} value whose index should
* be calculated.
@@ -106,7 +108,7 @@ public interface TabularData
* Compares the specified object with this object for equality.
* The object is judged equivalent if it is non-null, and also
* an instance of [EMAIL PROTECTED] TabularData} with the same row type,
- * and index to value mappings. The two compared instances may
+ * and [EMAIL PROTECTED] CompositeData} values. The two compared instances
may
* be equivalent even if they represent different implementations
* of [EMAIL PROTECTED] TabularData}.
*
@@ -123,9 +125,9 @@ public interface TabularData
* @return the matching [EMAIL PROTECTED] CompositeData} value, or
* <code>null</code> if one does not exist.
* @throws NullPointerException if the key is <code>null</code>.
- * @throws InvalidOpenTypeException if the key does not match
- * the [EMAIL PROTECTED] TabularType} of
this
- * instance.
+ * @throws InvalidKeyException if the key does not match
+ * the [EMAIL PROTECTED] TabularType} of this
+ * instance.
*/
CompositeData get(Object[] key);
@@ -138,14 +140,12 @@ public interface TabularData
TabularType getTabularType();
/**
- * Returns the hash code of the composite data type.
- * This is computed as the sum of the hash codes of the
- * each index and its value, together with the hash
- * code of the tabular type. These are the same elements
- * of the type that are compared as part of the
- * [EMAIL PROTECTED] #equals(java.lang.Object)} method, thus ensuring
- * that the hashcode is compatible with the equality
- * test.
+ * Returns the hash code of the composite data type. This is
+ * computed as the sum of the hash codes of each value, together
+ * with the hash code of the tabular type. These are the same
+ * elements of the type that are compared as part of the [EMAIL PROTECTED]
+ * #equals(java.lang.Object)} method, thus ensuring that the
+ * hashcode is compatible with the equality test.
*
* @return the hash code of this instance.
*/
@@ -196,15 +196,16 @@ public interface TabularData
* values in the array, as well as from the existing values
* in the table. The operation should be atomic; if one
* value can not be added, then none of the values should
- * be.
+ * be. If the array is <code>null</code> or empty, the
+ * method simply returns.
*
* @param vals the [EMAIL PROTECTED] CompositeData} values to add.
- * @throws NullPointerException if <code>val</code> is
+ * @throws NullPointerException if a value from the array is
* <code>null</code>.
- * @throws InvalidOpenTypeException if the type of the
+ * @throws InvalidOpenTypeException if the type of a
* given value does not
* match the row type.
- * @throws KeyAlreadyExistsException if the value has the
+ * @throws KeyAlreadyExistsException if a value has the
* same calculated index
* as an existing value or
* of one of the other
Index: javax/management/openmbean/TabularDataSupport.java
===================================================================
RCS file: javax/management/openmbean/TabularDataSupport.java
diff -N javax/management/openmbean/TabularDataSupport.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ javax/management/openmbean/TabularDataSupport.java 4 Aug 2006 21:29:15
-0000
@@ -0,0 +1,652 @@
+/* TabularDataSupport.java -- Tables of composite data structures.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.io.Serializable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provides an implementation of the [EMAIL PROTECTED] TabularData}
+ * interface using a [EMAIL PROTECTED] java.util.HashMap}.
+ *
+ * @author Andrew John Hughes ([EMAIL PROTECTED])
+ * @since 1.5
+ */
+public class TabularDataSupport
+ implements TabularData, Serializable, Cloneable, Map
+{
+
+ /**
+ * Compatible with JDK 1.5
+ */
+ private static final long serialVersionUID = 5720150593236309827L;
+
+ /**
+ * Mapping of rows to column values.
+ *
+ * @serial the map of rows to column values.
+ */
+ private Map dataMap;
+
+ /**
+ * The tabular type which represents this tabular data instance.
+ *
+ * @serial the type information for this instance.
+ */
+ private TabularType tabularType;
+
+ /**
+ * Constructs a new empty [EMAIL PROTECTED] TabularDataSupport} with the
+ * specified type. The type may not be null. This constructor
+ * simply calls the other, with the default initial capacity of
+ * <code>101</code> and default load factor of <code>0.75</code>.
+ *
+ * @param type the tabular type of this tabular data instance.
+ * @throws IllegalArgumentException if <code>type</code> is
+ * <code>null</code>.
+ */
+ public TabularDataSupport(TabularType type)
+ {
+ this(type, 101, 0.75f);
+ }
+
+ /**
+ * Constructs a new empty [EMAIL PROTECTED] TabularDataSupport} with the
+ * specified type and the supplied initial capacity and load factor
+ * being used for the underlying [EMAIL PROTECTED] java.util.HashMap}. The
+ * type may not be null and the initial capacity and load factor
+ * must be positive.
+ *
+ * @param type the tabular type of this tabular data instance.
+ * @param cap the initial capacity of the underlying map.
+ * @param lf the load factor of the underlying map.
+ * @throws IllegalArgumentException if <code>type</code> is
+ * <code>null</code>, or
+ * <code>cap</code> or
+ * <code>lf</code> are
+ * negative.
+ */
+ public TabularDataSupport(TabularType type, int cap, float lf)
+ {
+ if (type == null)
+ throw new IllegalArgumentException("The type may not be null.");
+ tabularType = type;
+ dataMap = new HashMap(cap, lf);
+ }
+
+ /**
+ * Calculates the index the specified [EMAIL PROTECTED] CompositeData} value
+ * would have, if it was to be added to this [EMAIL PROTECTED] TabularData}
+ * instance. This method includes a check that the type of the
+ * given value is the same as the row type of this instance, but not
+ * a check for existing instances of the given value. The value
+ * must also not be <code>null</code>. Possible indices are
+ * selected by the [EMAIL PROTECTED] TabularType#getIndexNames()} method of
+ * this instance's tabular type. The returned indices are the
+ * values of the fields in the supplied [EMAIL PROTECTED] CompositeData}
+ * instance that match the names given in the [EMAIL PROTECTED] TabularType}.
+ *
+ * @param val the [EMAIL PROTECTED] CompositeData} value whose index should
+ * be calculated.
+ * @return the index the value would take on, if it were to be added.
+ * @throws NullPointerException if the value is <code>null</code>.
+ * @throws InvalidOpenTypeException if the value does not match the
+ * row type of this instance.
+ */
+ public Object[] calculateIndex(CompositeData val)
+ {
+ if (!(val.getCompositeType().equals(tabularType.getRowType())))
+ throw new InvalidOpenTypeException("The type of the given value " +
+ "does not match the row type " +
+ "of this instance.");
+ List indexNames = tabularType.getIndexNames();
+ List matchingIndicies = new ArrayList(indexNames.size());
+ Iterator it = indexNames.iterator();
+ while (it.hasNext())
+ {
+ String name = (String) it.next();
+ matchingIndicies.add(val.get(name));
+ }
+ return matchingIndicies.toArray();
+ }
+
+ /**
+ * Removes all [EMAIL PROTECTED] CompositeData} values from the table.
+ */
+ public void clear()
+ {
+ dataMap.clear();
+ }
+
+ /**
+ * Returns a shallow clone of the information, as obtained by the
+ * [EMAIL PROTECTED] Object} implementation of [EMAIL PROTECTED]
Object#clone()}. The map
+ * is also cloned, but it still references the same objects.
+ *
+ * @return a shallow clone of this [EMAIL PROTECTED] TabularDataSupport}.
+ */
+ public Object clone()
+ {
+ TabularDataSupport clone = null;
+ try
+ {
+ clone = (TabularDataSupport) super.clone();
+ clone.setMap((HashMap) ((HashMap) dataMap).clone());
+ }
+ catch (CloneNotSupportedException e)
+ {
+ /* This won't happen as we implement Cloneable */
+ }
+ return clone;
+ }
+
+ /**
+ * Returns true iff this instance of the [EMAIL PROTECTED] TabularData} class
+ * contains a [EMAIL PROTECTED] CompositeData} value at the specified index.
+ * The method returns <code>false</code> if the given key can
+ * not be cast to an [EMAIL PROTECTED] java.lang.Object} array; otherwise
+ * it returns the result of [EMAIL PROTECTED]
#containsKey(java.lang.Object[])}.
+ *
+ *
+ * @param key the key to test for.
+ * @return true if the key maps to a [EMAIL PROTECTED] CompositeData} value.
+ */
+ public boolean containsKey(Object key)
+ {
+ if (key instanceof Object[])
+ return containsKey((Object[]) key);
+ else
+ return false;
+ }
+
+ /**
+ * Returns true iff this instance of the [EMAIL PROTECTED] TabularData} class
+ * contains a [EMAIL PROTECTED] CompositeData} value at the specified index.
+ * In any other circumstance, including if the given key
+ * is <code>null</code> or of the incorrect type, according to
+ * the [EMAIL PROTECTED] TabularType} of this instance, this method returns
+ * false.
+ *
+ * @param key the key to test for.
+ * @return true if the key maps to a [EMAIL PROTECTED] CompositeData} value.
+ */
+ public boolean containsKey(Object[] key)
+ {
+ if (key == null)
+ return false;
+ if (!(isKeyValid(key)))
+ return false;
+ return dataMap.containsKey(key);
+ }
+
+ /**
+ * Returns true iff this instance of the [EMAIL PROTECTED] TabularData} class
+ * contains the specified [EMAIL PROTECTED] CompositeData} value. If the
given
+ * value is not an instance of [EMAIL PROTECTED] CompositeData}, this method
+ * simply returns false.
+ *
+ * @param val the value to test for.
+ * @return true if the value exists.
+ */
+ public boolean containsValue(Object val)
+ {
+ if (val instanceof CompositeData)
+ return containsValue((CompositeData) val);
+ else
+ return false;
+ }
+
+ /**
+ * Returns true iff this instance of the [EMAIL PROTECTED] TabularData} class
+ * contains the specified [EMAIL PROTECTED] CompositeData} value.
+ * In any other circumstance, including if the given value
+ * is <code>null</code> or of the incorrect type, according to
+ * the [EMAIL PROTECTED] TabularType} of this instance, this method returns
+ * false.
+ *
+ * @param val the value to test for.
+ * @return true if the value exists.
+ */
+ public boolean containsValue(CompositeData val)
+ {
+ if (val == null)
+ return false;
+ if (!(val.getCompositeType().equals(tabularType.getRowType())))
+ return false;
+ return dataMap.containsValue(val);
+ }
+
+ /**
+ * <p>
+ * Returns a set view of the mappings in this Map. Each element in the
+ * set is a Map.Entry. The set is backed by the map, so that changes in
+ * one show up in the other. Modifications made while an iterator is
+ * in progress cause undefined behavior. If the set supports removal,
+ * these methods remove the underlying mapping from the map:
+ * <code>Iterator.remove</code>, <code>Set.remove</code>,
+ * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>.
+ * Element addition, via <code>add</code> or <code>addAll</code>, is
+ * not supported via this set.
+ * </p>
+ * <p>
+ * <strong>Note</strong>: using the
+ * [EMAIL PROTECTED] java.util.Map.Entry#setValue(Object) will cause
corruption of
+ * the index to row mappings.
+ * </p>
+ *
+ * @return the set view of all mapping entries
+ * @see java.util.Map.Entry
+ */
+ public Set entrySet()
+ {
+ return dataMap.entrySet();
+ }
+
+ /**
+ * Compares the specified object with this object for equality.
+ * The object is judged equivalent if it is non-null, and also
+ * an instance of [EMAIL PROTECTED] TabularData} with the same row type,
+ * and [EMAIL PROTECTED] CompositeData} values. The two compared instances
may
+ * be equivalent even if they represent different implementations
+ * of [EMAIL PROTECTED] TabularData}.
+ *
+ * @param obj the object to compare for equality.
+ * @return true if <code>obj</code> is equal to <code>this</code>.
+ */
+ public boolean equals(Object obj)
+ {
+ if (!(obj instanceof TabularData))
+ return false;
+ TabularData data = (TabularData) obj;
+ return tabularType.equals(data.getTabularType()) &&
+ dataMap.values().equals(data.values());
+ }
+
+ /**
+ * Retrieves the value for the specified key by simply
+ * calling <code>get((Object[]) key)</code>.
+ *
+ * @param key the key whose value should be returned.
+ * @return the matching [EMAIL PROTECTED] CompositeData} value, or
+ * <code>null</code> if one does not exist.
+ * @throws NullPointerException if the key is <code>null</code>.
+ * @throws ClassCastException if the key is not an instance
+ * of <code>Object[]</code>.
+ * @throws InvalidKeyException if the key does not match
+ * the [EMAIL PROTECTED] TabularType} of this
+ * instance.
+ */
+ public Object get(Object key)
+ {
+ return get((Object[]) key);
+ }
+
+ /**
+ * Retrieves the [EMAIL PROTECTED] CompositeData} value for the specified
+ * key, or <code>null</code> if no such mapping exists.
+ *
+ * @param key the key whose value should be returned.
+ * @return the matching [EMAIL PROTECTED] CompositeData} value, or
+ * <code>null</code> if one does not exist.
+ * @throws NullPointerException if the key is <code>null</code>.
+ * @throws InvalidKeyException if the key does not match
+ * the [EMAIL PROTECTED] TabularType} of this
+ * instance.
+ */
+ public CompositeData get(Object[] key)
+ {
+ if (!(isKeyValid(key)))
+ throw new InvalidKeyException("The key does not match the " +
+ "tabular type of this instance.");
+ return (CompositeData) dataMap.get(key);
+ }
+
+ /**
+ * Returns the tabular type which corresponds to this instance
+ * of [EMAIL PROTECTED] TabularData}.
+ *
+ * @return the tabular type for this instance.
+ */
+ public TabularType getTabularType()
+ {
+ return tabularType;
+ }
+
+ /**
+ * Returns the hash code of the composite data type. This is
+ * computed as the sum of the hash codes of each value, together
+ * with the hash code of the tabular type. These are the same
+ * elements of the type that are compared as part of the [EMAIL PROTECTED]
+ * #equals(java.lang.Object)} method, thus ensuring that the
+ * hashcode is compatible with the equality test.
+ *
+ * @return the hash code of this instance.
+ */
+ public int hashCode()
+ {
+ return tabularType.hashCode() + dataMap.values().hashCode();
+ }
+
+ /**
+ * Returns true if this [EMAIL PROTECTED] TabularData} instance
+ * contains no [EMAIL PROTECTED] CompositeData} values.
+ *
+ * @return true if the instance is devoid of rows.
+ */
+ public boolean isEmpty()
+ {
+ return dataMap.isEmpty();
+ }
+
+ /**
+ * Returns true if the given key is valid for the
+ * @link{TabularType} of this instance.
+ *
+ * @return true if the key is valid.
+ * @throws NullPointerException if <code>key</code>
+ * is null.
+ */
+ private boolean isKeyValid(Object[] key)
+ {
+ Iterator it = tabularType.getIndexNames().iterator();
+ CompositeType rowType = tabularType.getRowType();
+ for (int a = 0; it.hasNext(); ++a)
+ {
+ OpenType type = rowType.getType((String) it.next());
+ if (!(type.isValue(key[a])))
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns a set view of the keys in this Map. The set is backed by the
+ * map, so that changes in one show up in the other. Modifications made
+ * while an iterator is in progress cause undefined behavior. If the set
+ * supports removal, these methods remove the underlying mapping from
+ * the map: <code>Iterator.remove</code>, <code>Set.remove</code>,
+ * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>.
+ * Element addition, via <code>add</code> or <code>addAll</code>, is
+ * not supported via this set.
+ *
+ * @return the set view of all keys
+ */
+ public Set keySet()
+ {
+ return dataMap.keySet();
+ }
+
+ /**
+ * Adds the specified [EMAIL PROTECTED] CompositeData} value to the
+ * table. The value must be non-null, of the same type
+ * as the row type of this instance, and must not have
+ * the same index as an existing value. The index is
+ * calculated using the index names of the
+ * [EMAIL PROTECTED] TabularType} for this instance.
+ *
+ * @param val the [EMAIL PROTECTED] CompositeData} value to add.
+ * @throws NullPointerException if <code>val</code> is
+ * <code>null</code>.
+ * @throws InvalidOpenTypeException if the type of the
+ * given value does not
+ * match the row type.
+ * @throws KeyAlreadyExistsException if the value has the
+ * same calculated index
+ * as an existing value.
+ */
+ public void put(CompositeData val)
+ {
+ Object[] key = calculateIndex(val);
+ if (dataMap.containsKey(key))
+ throw new KeyAlreadyExistsException("A value with this index " +
+ "already exists.");
+ dataMap.put(key, val);
+ }
+
+ /**
+ * Adds the specified [EMAIL PROTECTED] CompositeData} value to the
+ * table, ignoring the supplied key, by simply calling
+ * <code>put((CompositeData) val)</code>.
+ *
+ * @param key ignored.
+ * @param val the [EMAIL PROTECTED] CompositeData} value to add.
+ * @return the [EMAIL PROTECTED] CompositeData} value.
+ * @throws NullPointerException if <code>val</code> is
+ * <code>null</code>.
+ * @throws InvalidOpenTypeException if the type of the
+ * given value does not
+ * match the row type.
+ * @throws KeyAlreadyExistsException if the value has the
+ * same calculated index
+ * as an existing value.
+ */
+ public Object put(Object key, Object val)
+ {
+ put((CompositeData) val);
+ return val;
+ }
+
+ /**
+ * Adds each of the specified [EMAIL PROTECTED] CompositeData} values
+ * to the table. Each element of the array must meet the
+ * conditions given for the [EMAIL PROTECTED] #put(CompositeData)}
+ * method. In addition, the index of each value in the
+ * array must be distinct from the index of the other
+ * values in the array, as well as from the existing values
+ * in the table. The operation should be atomic; if one
+ * value can not be added, then none of the values should
+ * be. If the array is <code>null</code> or empty, the
+ * method simply returns.
+ *
+ * @param vals the [EMAIL PROTECTED] CompositeData} values to add.
+ * @throws NullPointerException if a value from the array is
+ * <code>null</code>.
+ * @throws InvalidOpenTypeException if the type of a
+ * given value does not
+ * match the row type.
+ * @throws KeyAlreadyExistsException if a value has the
+ * same calculated index
+ * as an existing value or
+ * of one of the other
+ * specified values.
+ */
+ public void putAll(CompositeData[] vals)
+ {
+ if (vals == null || vals.length == 0)
+ return;
+ Map mapToAdd = new HashMap(vals.length);
+ for (int a = 0; a < vals.length; ++a)
+ {
+ Object[] key = calculateIndex(vals[a]);
+ if (dataMap.containsKey(key))
+ throw new KeyAlreadyExistsException("Element " + a + ": A " +
+ "value with this index " +
+ "already exists.");
+ mapToAdd.put(key, vals[a]);
+ }
+ dataMap.putAll(mapToAdd);
+ }
+
+ /**
+ * Converts each value from the specified map to a member of an
+ * array of [EMAIL PROTECTED] CompositeData} values and adds them using
[EMAIL PROTECTED]
+ * #put(CompositeData[])}, if possible. As in [EMAIL PROTECTED]
+ * #put(Object,Object)}, the keys are simply ignored. This method
+ * is useful for adding the [EMAIL PROTECTED] CompositeData} values from a
+ * different [EMAIL PROTECTED] TabularData} instance, which uses the same
+ * [EMAIL PROTECTED] TabularType} but a different selection of index names,
to
+ * this one. If the map is <code>null</code> or empty, the method
+ * simply returns.
+ *
+ * @param m the map to add. Only the values are used and must
+ * all be instances of [EMAIL PROTECTED] CompositeData}.
+ * @throws NullPointerException if a value from the map is
+ * <code>null</code>.
+ * @throws ClassCastException if a value from the map is not
+ * an instance of [EMAIL PROTECTED]
CompositeData}.
+ * @throws InvalidOpenTypeException if the type of the
+ * given value does not
+ * match the row type.
+ * @throws KeyAlreadyExistsException if the value has the
+ * same calculated index
+ * as an existing value or
+ * of one of the other
+ * specified values.
+ */
+ public void putAll(Map m)
+ {
+ if (m == null || m.size() == 0)
+ return;
+ Collection vals = m.values();
+ CompositeData[] data = new CompositeData[vals.size()];
+ Iterator it = vals.iterator();
+ for (int a = 0; it.hasNext(); ++a)
+ {
+ data[a] = (CompositeData) it.next();
+ }
+ putAll(data);
+ }
+
+ /**
+ * Removes the value for the specified key by simply
+ * calling <code>remove((Object[]) key)</code>.
+ *
+ * @param key the key whose value should be removed.
+ * @return the removed value, or <code>null</code> if
+ * there is no value for the given key.
+ * @throws NullPointerException if the key is <code>null</code>.
+ * @throws ClassCastException if the key is not an instance
+ * of <code>Object[]</code>.
+ * @throws InvalidOpenTypeException if the key does not match
+ * the [EMAIL PROTECTED] TabularType} of
this
+ * instance.
+ */
+ public Object remove(Object key)
+ {
+ return remove((Object[]) key);
+ }
+
+ /**
+ * Removes the [EMAIL PROTECTED] CompositeData} value located at the
+ * specified index. <code>null</code> is returned if the
+ * value does not exist. Otherwise, the removed value is
+ * returned.
+ *
+ * @param key the key of the value to remove.
+ * @return the removed value, or <code>null</code> if
+ * there is no value for the given key.
+ * @throws NullPointerException if the key is <code>null</code>.
+ * @throws InvalidOpenTypeException if the key does not match
+ * the [EMAIL PROTECTED] TabularType} of
this
+ * instance.
+ */
+ public CompositeData remove(Object[] key)
+ {
+ if (!(isKeyValid(key)))
+ throw new InvalidKeyException("The key does not match the " +
+ "tabular type of this instance.");
+ return (CompositeData) dataMap.remove(key);
+ }
+
+ /**
+ * Package-private method to set the internal [EMAIL PROTECTED]
java.util.Map}
+ * instance (used in cloning).
+ *
+ * @param map the new map used.
+ */
+ void setMap(Map map)
+ {
+ dataMap = map;
+ }
+
+ /**
+ * Returns the number of [EMAIL PROTECTED] CompositeData} values or rows
+ * in the table.
+ *
+ * @return the number of rows in the table.
+ */
+ public int size()
+ {
+ return dataMap.size();
+ }
+
+ /**
+ * Returns a textual representation of this instance. This
+ * is constructed using the class name
+ * (<code>javax.management.openmbean.TabularDataSupport</code>)
+ * and the result of calling <code>toString()</code> on the
+ * tabular type and underlying hash map instance.
+ *
+ * @return a [EMAIL PROTECTED] java.lang.String} representation of the
+ * object.
+ */
+ public String toString()
+ {
+ return getClass().getName()
+ + "[tabularType=" + tabularType
+ + ",dataMap=" + dataMap
+ + "]";
+ }
+
+ /**
+ * Returns a collection (or bag) view of the values in this Map. The
+ * collection is backed by the map, so that changes in one show up in
+ * the other. Modifications made while an iterator is in progress cause
+ * undefined behavior. If the collection supports removal, these methods
+ * remove the underlying mapping from the map: <code>Iterator.remove</code>,
+ * <code>Collection.remove</code>, <code>removeAll</code>,
+ * <code>retainAll</code>, and <code>clear</code>. Element addition, via
+ * <code>add</code> or <code>addAll</code>, is not supported via this
+ * collection.
+ *
+ * @return the collection view of all values
+ */
+ public Collection values()
+ {
+ return dataMap.values();
+ }
+
+}
+
signature.asc
Description: Digital signature
