mirror of
https://github.com/autc04/Retro68.git
synced 2025-02-21 09:29:36 +00:00
649 lines
23 KiB
Java
649 lines
23 KiB
Java
/* TabularDataSupport.java -- Tables of composite data structures.
|
|
Copyright (C) 2006, 2007 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 {@link TabularData}
|
|
* interface using a {@link java.util.HashMap}.
|
|
*
|
|
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
|
|
* @since 1.5
|
|
*/
|
|
public class TabularDataSupport
|
|
implements TabularData, Serializable, Cloneable, Map<Object,Object>
|
|
{
|
|
|
|
/**
|
|
* 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 HashMap<Object,Object> dataMap;
|
|
|
|
/**
|
|
* The tabular type which represents this tabular data instance.
|
|
*
|
|
* @serial the type information for this instance.
|
|
*/
|
|
private TabularType tabularType;
|
|
|
|
/**
|
|
* Constructs a new empty {@link 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 {@link TabularDataSupport} with the
|
|
* specified type and the supplied initial capacity and load factor
|
|
* being used for the underlying {@link 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<Object,Object>(cap, lf);
|
|
}
|
|
|
|
/**
|
|
* Calculates the index the specified {@link CompositeData} value
|
|
* would have, if it was to be added to this {@link 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 {@link TabularType#getIndexNames()} method of
|
|
* this instance's tabular type. The returned indices are the
|
|
* values of the fields in the supplied {@link CompositeData}
|
|
* instance that match the names given in the {@link TabularType}.
|
|
*
|
|
* @param val the {@link 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<String> indexNames = tabularType.getIndexNames();
|
|
List<String> matchingIndicies = new ArrayList<String>(indexNames.size());
|
|
for (String name : indexNames)
|
|
matchingIndicies.add(val.get(name).toString());
|
|
return matchingIndicies.toArray();
|
|
}
|
|
|
|
/**
|
|
* Removes all {@link CompositeData} values from the table.
|
|
*/
|
|
public void clear()
|
|
{
|
|
dataMap.clear();
|
|
}
|
|
|
|
/**
|
|
* Returns a shallow clone of the information, as obtained by the
|
|
* {@link Object} implementation of {@link Object#clone()}. The map
|
|
* is also cloned, but it still references the same objects.
|
|
*
|
|
* @return a shallow clone of this {@link TabularDataSupport}.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public Object clone()
|
|
{
|
|
TabularDataSupport clone = null;
|
|
try
|
|
{
|
|
clone = (TabularDataSupport) super.clone();
|
|
clone.setMap((HashMap<Object,Object>) dataMap.clone());
|
|
}
|
|
catch (CloneNotSupportedException e)
|
|
{
|
|
/* This won't happen as we implement Cloneable */
|
|
}
|
|
return clone;
|
|
}
|
|
|
|
/**
|
|
* Returns true iff this instance of the {@link TabularData} class
|
|
* contains a {@link CompositeData} value at the specified index.
|
|
* The method returns <code>false</code> if the given key can
|
|
* not be cast to an {@link java.lang.Object} array; otherwise
|
|
* it returns the result of {@link #containsKey(java.lang.Object[])}.
|
|
*
|
|
*
|
|
* @param key the key to test for.
|
|
* @return true if the key maps to a {@link 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 {@link TabularData} class
|
|
* contains a {@link 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 {@link TabularType} of this instance, this method returns
|
|
* false.
|
|
*
|
|
* @param key the key to test for.
|
|
* @return true if the key maps to a {@link 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 {@link TabularData} class
|
|
* contains the specified {@link CompositeData} value. If the given
|
|
* value is not an instance of {@link 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 {@link TabularData} class
|
|
* contains the specified {@link CompositeData} value.
|
|
* In any other circumstance, including if the given value
|
|
* is <code>null</code> or of the incorrect type, according to
|
|
* the {@link 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
|
|
* {@link 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<Map.Entry<Object,Object>> 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 {@link TabularData} with the same row type,
|
|
* and {@link CompositeData} values. The two compared instances may
|
|
* be equivalent even if they represent different implementations
|
|
* of {@link 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 {@link 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 {@link TabularType} of this
|
|
* instance.
|
|
*/
|
|
public Object get(Object key)
|
|
{
|
|
return get((Object[]) key);
|
|
}
|
|
|
|
/**
|
|
* Retrieves the {@link 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 {@link 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 {@link 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 {@link 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 {@link
|
|
* #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 {@link TabularData} instance
|
|
* contains no {@link 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<String> it = tabularType.getIndexNames().iterator();
|
|
CompositeType rowType = tabularType.getRowType();
|
|
for (int a = 0; it.hasNext(); ++a)
|
|
{
|
|
OpenType<?> type = rowType.getType(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<Object> keySet()
|
|
{
|
|
return dataMap.keySet();
|
|
}
|
|
|
|
/**
|
|
* Adds the specified {@link 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
|
|
* {@link TabularType} for this instance.
|
|
*
|
|
* @param val the {@link 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 {@link CompositeData} value to the
|
|
* table, ignoring the supplied key, by simply calling
|
|
* <code>put((CompositeData) val)</code>.
|
|
*
|
|
* @param key ignored.
|
|
* @param val the {@link CompositeData} value to add.
|
|
* @return the {@link 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 {@link CompositeData} values
|
|
* to the table. Each element of the array must meet the
|
|
* conditions given for the {@link #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 {@link 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<Object,Object> mapToAdd = new HashMap<Object,Object>(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 {@link CompositeData} values and adds them using {@link
|
|
* #put(CompositeData[])}, if possible. As in {@link
|
|
* #put(Object,Object)}, the keys are simply ignored. This method
|
|
* is useful for adding the {@link CompositeData} values from a
|
|
* different {@link TabularData} instance, which uses the same
|
|
* {@link 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 {@link 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 {@link 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 {@link TabularType} of this
|
|
* instance.
|
|
*/
|
|
public Object remove(Object key)
|
|
{
|
|
return remove((Object[]) key);
|
|
}
|
|
|
|
/**
|
|
* Removes the {@link 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 {@link 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);
|
|
}
|
|
|
|
/**
|
|
* Private method to set the internal {@link java.util.Map}
|
|
* instance (used in cloning).
|
|
*
|
|
* @param map the new map used.
|
|
*/
|
|
private void setMap(HashMap<Object,Object> map)
|
|
{
|
|
dataMap = map;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of {@link 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 {@link 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<Object> values()
|
|
{
|
|
return dataMap.values();
|
|
}
|
|
|
|
}
|