public TabularDataSupport(TabularType tabularType) 
{
        this(tabularType, 16, 0.75f);
}

Creates an empty TabularDataSupport instance whose open-type is tabularType, and whose underlying HashMap has a default initial capacity (101) and default load factor (0.75).

This constructor simply calls this(tabularType, 101, 0.75f);

Parameters:

tabularType - the tabular type describing this TabularData instance; cannot be null.

Throws:

IllegalArgumentException - if the tabular type is null.

 public TabularDataSupport(TabularType tabularType,
    int initialCapacity,
    float loadFactor) 
{
        // Check tabularType is not null
        //
        if (tabularType == null) {
            throw new IllegalArgumentException("Argument tabularType cannot be null.");
        }
        // Initialize this.tabularType (and indexNamesArray for convenience)
        //
        this.tabularType = tabularType;
        List< String > tmpNames = tabularType.getIndexNames();
        this.indexNamesArray = tmpNames.toArray(new String[tmpNames.size()]);
        // Since LinkedHashMap was introduced in SE 1.4, it's conceivable even
        // if very unlikely that we might be the server of a 1.3 client.  In
        // that case you'll need to set this property.  See CR 6334663.
        String useHashMapProp = AccessController.doPrivileged(
                new GetPropertyAction("jmx.tabular.data.hash.map"));
        boolean useHashMap = "true".equalsIgnoreCase(useHashMapProp);
        // Construct the empty contents HashMap
        //
        this.dataMap = useHashMap ?
            new HashMap< Object,CompositeData >(initialCapacity, loadFactor) :
            new LinkedHashMap< Object, CompositeData >(initialCapacity, loadFactor);
}

Creates an empty TabularDataSupport instance whose open-type is tabularType, and whose underlying HashMap has the specified initial capacity and load factor.

Parameters:

tabularType - the tabular type describing this TabularData instance; cannot be null.

initialCapacity - the initial capacity of the HashMap.

loadFactor - the load factor of the HashMap

Throws:

IllegalArgumentException - if the initial capacity is less than zero, or the load factor is nonpositive, or the tabular type is null.

 public Object[] calculateIndex(CompositeData value) 
{
        // Check value is valid
        //
        checkValueType(value);
        // Return its calculated index
        //
        return internalCalculateIndex(value).toArray();
}

Calculates the index that would be used in this TabularData instance to refer to the specified composite data value parameter if it were added to this instance. This method checks for the type validity of the specified value, but does not check if the calculated index is already used to refer to a value in this TabularData instance.

 public  void clear() 
{
        dataMap.clear();
}

Removes all rows from this TabularDataSupport instance.

 public Object clone() 
{
        try {
            TabularDataSupport c = (TabularDataSupport) super.clone();
            c.dataMap = new HashMap< Object,CompositeData >(c.dataMap);
            return c;
        }
        catch (CloneNotSupportedException e) {
            throw new InternalError(e.toString());
        }
}

Returns a clone of this TabularDataSupport instance: the clone is obtained by calling super.clone(), and then cloning the underlying map. Only a shallow clone of the underlying map is made, i.e. no cloning of the indexes and row values is made as they are immutable.

 public boolean containsKey(Object key) 
{
        // if key is not an array of Object instances, return false
        //
        Object[] k;
        try {
            k = (Object[]) key;
        } catch (ClassCastException e) {
            return false;
        }
        return  this.containsKey(k);
}

Returns true if and only if this TabularData instance contains a CompositeData value (ie a row) whose index is the specified key. If key cannot be cast to a one dimension array of Object instances, this method simply returns false; otherwise it returns the the result of the call to this.containsKey((Object[]) key).

 public boolean containsKey(Object[] key) 
{
        return  ( key == null ? false : dataMap.containsKey(Arrays.asList(key)));
}

Returns true if and only if this TabularData instance contains a CompositeData value (ie a row) whose index is the specified key. If key is null or does not conform to this TabularData instance's TabularType definition, this method simply returns false.

 public boolean containsValue(CompositeData value) 
{
        return dataMap.containsValue(value);
}

Returns true if and only if this TabularData instance contains the specified CompositeData value. If value is null or does not conform to this TabularData instance's row type definition, this method simply returns false.

 public boolean containsValue(Object value) 
{
        return dataMap.containsValue(value);
}

Returns true if and only if this TabularData instance contains the specified value.

 public Set<Object, Object> entrySet() 
{
        return Util.cast(dataMap.entrySet());
}

Returns a collection view of the index to row mappings contained in this {@code TabularDataSupport} instance. Each element in the returned collection is a {@code Map.Entry,CompositeData>} but is declared as a {@code Map.Entry} for compatibility reasons. Each of the map entry keys is an unmodifiable {@code List}. The collection is backed by the underlying map of this {@code TabularDataSupport} instance, so changes to the {@code TabularDataSupport} instance are reflected in the collection, and vice-versa. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator#remove , Collection#remove , Collection#removeAll , Collection#retainAll , and Collection#clear operations. It does not support the Collection#add or Collection#addAll operations.

IMPORTANT NOTICE: Do not use the {@code setValue} method of the {@code Map.Entry} elements contained in the returned collection view. Doing so would corrupt the index to row mappings contained in this {@code TabularDataSupport} instance.

 public boolean equals(Object obj) 
{
        // if obj is null, return false
        //
        if (obj == null) {
            return false;
        }
        // if obj is not a TabularData, return false
        //
        TabularData other;
        try {
            other = (TabularData) obj;
        } catch (ClassCastException e) {
            return false;
        }
        // Now, really test for equality between this TabularData implementation and the other:
        //
        // their tabularType should be equal
        if ( ! this.getTabularType().equals(other.getTabularType()) ) {
            return false;
        }
        // their contents should be equal:
        // . same size
        // . values in this instance are in the other (we know there are no duplicate elements possible)
        // (row values comparison is enough, because keys are calculated according to tabularType)
        if (this.size() != other.size()) {
            return false;
        }
        for (CompositeData value : dataMap.values()) {
            if ( ! other.containsValue(value) ) {
                return false;
            }
        }
        // All tests for equality were successfull
        //
        return true;
}

Compares the specified obj parameter with this TabularDataSupport instance for equality.

Returns true if and only if all of the following statements are true:

• obj is non null,
• obj also implements the TabularData interface,
• their tabular types are equal
• their contents (ie all CompositeData values) are equal.
This ensures that this equals method works properly for obj parameters which are different implementations of the TabularData interface.
 

 public Object get(Object key) 
{
        return get((Object[]) key);
}

This method simply calls get((Object[]) key).

 public CompositeData get(Object[] key) 
{
        // Check key is not null and valid with tabularType
        // (throws NullPointerException, InvalidKeyException)
        //
        checkKeyType(key);
        // Return the mapping stored in the parent HashMap
        //
        return dataMap.get(Arrays.asList(key));
}

Returns the CompositeData value whose index is key, or null if there is no value mapping to key, in this TabularData instance.

 public TabularType getTabularType() 
{
        return tabularType;
}

Returns the tabular type describing this TabularData instance.

 public int hashCode() 
{
        int result = 0;
        result += this.tabularType.hashCode();
        for (Object value : values())
            result += value.hashCode();
        return result;
}

Returns the hash code value for this TabularDataSupport instance.

The hash code of a TabularDataSupport instance is the sum of the hash codes of all elements of information used in equals comparisons (ie: its tabular type and its content, where the content is defined as all the CompositeData values).

This ensures that t1.equals(t2) implies that t1.hashCode()==t2.hashCode() for any two TabularDataSupport instances t1 and t2, as required by the general contract of the method Object.hashCode() .

However, note that another instance of a class implementing the TabularData interface may be equal to this TabularDataSupport instance as defined by #equals , but may have a different hash code if it is calculated differently.

 public boolean isEmpty() 
{
        return (this.size() == 0);
}

Returns true if this TabularDataSupport instance contains no rows.

 public Set<Object> keySet() 
{
        return dataMap.keySet() ;
}

Returns a set view of the keys contained in the underlying map of this {@code TabularDataSupport} instance used to index the rows. Each key contained in this {@code Set} is an unmodifiable {@code List} so the returned set view is a {@code Set>} but is declared as a {@code Set

 public  void put(CompositeData value) 
{
        internalPut(value);
}

 public Object put(Object key,
    Object value) 
{
        internalPut((CompositeData) value);
        return value; // should be return internalPut(...); (5090566)
}

This method simply calls put((CompositeData) value) and therefore ignores its key parameter which can be null.

 public  void putAll(Map<?, ?> t) 
{
        // if t is null or empty, just return
        //
        if ( (t == null) || (t.size() == 0) ) {
            return;
        }
        // Convert the values in t into an array of < tt >CompositeData< /tt >
        //
        CompositeData[] values;
        try {
            values =
                t.values().toArray(new CompositeData[t.size()]);
        } catch (java.lang.ArrayStoreException e) {
            throw new ClassCastException("Map argument t contains values which are not instances of < tt >CompositeData< /tt >");
        }
        // Add the array of values
        //
        putAll(values);
}

Add all the values contained in the specified map t to this TabularData instance. This method converts the collection of values contained in this map into an array of CompositeData values, if possible, and then call the method putAll(CompositeData[]). Note that the keys used in the specified map t are ignored. This method allows, for example to add the content of another TabularData instance with the same row type (but possibly different index names) into this instance.

 public  void putAll(CompositeData[] values) 
{
        // if values is null or empty, just return
        //
        if ( (values == null) || (values.length == 0) ) {
            return;
        }
        // create the list of indexes corresponding to each value
        List< List< ? > > indexes =
            new ArrayList< List< ? > >(values.length + 1);
        // Check all elements in values and build index list
        //
        List< ? > index;
        for (int i=0; i< values.length; i++) {
            // check value and calculate index
            index = checkValueAndIndex(values[i]);
            // check index is different of those previously calculated
            if (indexes.contains(index)) {
                throw new KeyAlreadyExistsException("Argument elements values["+ i +"] and values["+ indexes.indexOf(index) +
                                                    "] have the same indexes, "+
                                                    "calculated according to this TabularData instance's tabularType.");
            }
            // add to index list
            indexes.add(index);
        }
        // store all (index, value) mappings in the dataMap HashMap
        //
        for (int i=0; i< values.length; i++) {
            dataMap.put(indexes.get(i), values[i]);
        }
}

Add all the elements in values to this TabularData instance. If any element in values does not satisfy the constraints defined in put , or if any two elements in values have the same index calculated according to this TabularData instance's TabularType definition, then an exception describing the failure is thrown and no element of values is added, thus leaving this TabularData instance unchanged.

 public Object remove(Object key) 
{
        return remove((Object[]) key);
}

This method simply calls remove((Object[]) key).

 public CompositeData remove(Object[] key) 
{
        // Check key is not null and valid with tabularType
        // (throws NullPointerException, InvalidKeyException)
        //
        checkKeyType(key);
        // Removes the (key, value) mapping in the parent HashMap
        //
        return dataMap.remove(Arrays.asList(key));
}

Removes the CompositeData value whose index is key from this TabularData instance, and returns the removed value, or returns null if there is no value whose index is key.

 public int size() 
{
        return dataMap.size();
}

Returns the number of rows in this TabularDataSupport instance.

 public String toString() 
{
        return new StringBuilder()
            .append(this.getClass().getName())
            .append("(tabularType=")
            .append(tabularType.toString())
            .append(",contents=")
            .append(dataMap.toString())
            .append(")")
            .toString();
}

Returns a string representation of this TabularDataSupport instance.

The string representation consists of the name of this class (ie javax.management.openmbean.TabularDataSupport), the string representation of the tabular type of this instance, and the string representation of the contents (ie list the key=value mappings as returned by a call to dataMap.toString() ).

 public Collection<Object> values() 
{
        return Util.cast(dataMap.values());
}

Returns a collection view of the rows contained in this {@code TabularDataSupport} instance. The returned {@code Collection} is a {@code Collection} but is declared as a {@code Collection