Back to index...

	/*
	* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing;

	import java.io.IOException;
	import java.io.ObjectOutputStream;
	import java.io.Serializable;
	import java.util.Enumeration;
	import java.util.Hashtable;

	/*
	* Private storage mechanism for Action key-value pairs.
	* In most cases this will be an array of alternating
	* key-value pairs. As it grows larger it is scaled
	* up to a Hashtable.
	* <p>
	* This does no synchronization, if you need thread safety synchronize on
	* another object before calling this.
	*
	* @author Georges Saab
	* @author Scott Violet
	*/
	class ArrayTable implements Cloneable {
	// Our field for storage
	private Object table = null;
	private static final int ARRAY_BOUNDARY = 8;


	/**
	* Writes the passed in ArrayTable to the passed in ObjectOutputStream.
	* The data is saved as an integer indicating how many key/value
	* pairs are being archived, followed by the the key/value pairs. If
	* <code>table</code> is null, 0 will be written to <code>s</code>.
	* <p>
	* This is a convenience method that ActionMap/InputMap and
	* AbstractAction use to avoid having the same code in each class.
	*/
	static void writeArrayTable(ObjectOutputStream s, ArrayTable table) throws IOException {
	Object keys[];

	if (table == null \|\| (keys = table.getKeys(null)) == null) {
	s.writeInt(0);
	}
	else {
	// Determine how many keys have Serializable values, when
	// done all non-null values in keys identify the Serializable
	// values.
	int validCount = 0;

	for (int counter = 0; counter < keys.length; counter++) {
	Object key = keys[counter];

	/* include in Serialization when both keys and values are Serializable */
	if ( (key instanceof Serializable
	&& table.get(key) instanceof Serializable)
	\|\|
	/* include these only so that we get the appropriate exception below */
	(key instanceof ClientPropertyKey
	&& ((ClientPropertyKey)key).getReportValueNotSerializable())) {

	validCount++;
	} else {
	keys[counter] = null;
	}
	}
	// Write ou the Serializable key/value pairs.
	s.writeInt(validCount);
	if (validCount > 0) {
	for (Object key : keys) {
	if (key != null) {
	s.writeObject(key);
	s.writeObject(table.get(key));
	if (--validCount == 0) {
	break;
	}
	}
	}
	}
	}
	}


	/*
	* Put the key-value pair into storage
	*/
	public void put(Object key, Object value){
	if (table==null) {
	table = new Object[] {key, value};
	} else {
	int size = size();
	if (size < ARRAY_BOUNDARY) { // We are an array
	if (containsKey(key)) {
	Object[] tmp = (Object[])table;
	for (int i = 0; i<tmp.length-1; i+=2) {
	if (tmp[i].equals(key)) {
	tmp[i+1]=value;
	break;
	}
	}
	} else {
	Object[] array = (Object[])table;
	int i = array.length;
	Object[] tmp = new Object[i+2];
	System.arraycopy(array, 0, tmp, 0, i);

	tmp[i] = key;
	tmp[i+1] = value;
	table = tmp;
	}
	} else { // We are a hashtable
	if ((size==ARRAY_BOUNDARY) && isArray()) {
	grow();
	}
	((Hashtable<Object,Object>)table).put(key, value);
	}
	}
	}

	/*
	* Gets the value for key
	*/
	public Object get(Object key) {
	Object value = null;
	if (table !=null) {
	if (isArray()) {
	Object[] array = (Object[])table;
	for (int i = 0; i<array.length-1; i+=2) {
	if (array[i].equals(key)) {
	value = array[i+1];
	break;
	}
	}
	} else {
	value = ((Hashtable)table).get(key);
	}
	}
	return value;
	}

	/*
	* Returns the number of pairs in storage
	*/
	public int size() {
	int size;
	if (table==null)
	return 0;
	if (isArray()) {
	size = ((Object[])table).length/2;
	} else {
	size = ((Hashtable)table).size();
	}
	return size;
	}

	/*
	* Returns true if we have a value for the key
	*/
	public boolean containsKey(Object key) {
	boolean contains = false;
	if (table !=null) {
	if (isArray()) {
	Object[] array = (Object[])table;
	for (int i = 0; i<array.length-1; i+=2) {
	if (array[i].equals(key)) {
	contains = true;
	break;
	}
	}
	} else {
	contains = ((Hashtable)table).containsKey(key);
	}
	}
	return contains;
	}

	/*
	* Removes the key and its value
	* Returns the value for the pair removed
	*/
	public Object remove(Object key){
	Object value = null;
	if (key==null) {
	return null;
	}
	if (table !=null) {
	if (isArray()){
	// Is key on the list?
	int index = -1;
	Object[] array = (Object[])table;
	for (int i = array.length-2; i>=0; i-=2) {
	if (array[i].equals(key)) {
	index = i;
	value = array[i+1];
	break;
	}
	}

	// If so, remove it
	if (index != -1) {
	Object[] tmp = new Object[array.length-2];
	// Copy the list up to index
	System.arraycopy(array, 0, tmp, 0, index);
	// Copy from two past the index, up to
	// the end of tmp (which is two elements
	// shorter than the old list)
	if (index < tmp.length)
	System.arraycopy(array, index+2, tmp, index,
	tmp.length - index);
	// set the listener array to the new array or null
	table = (tmp.length == 0) ? null : tmp;
	}
	} else {
	value = ((Hashtable)table).remove(key);
	}
	if (size()==ARRAY_BOUNDARY - 1 && !isArray()) {
	shrink();
	}
	}
	return value;
	}

	/**
	* Removes all the mappings.
	*/
	public void clear() {
	table = null;
	}

	/*
	* Returns a clone of the <code>ArrayTable</code>.
	*/
	public Object clone() {
	ArrayTable newArrayTable = new ArrayTable();
	if (isArray()) {
	Object[] array = (Object[])table;
	for (int i = 0 ;i < array.length-1 ; i+=2) {
	newArrayTable.put(array[i], array[i+1]);
	}
	} else {
	Hashtable<?,?> tmp = (Hashtable)table;
	Enumeration<?> keys = tmp.keys();
	while (keys.hasMoreElements()) {
	Object o = keys.nextElement();
	newArrayTable.put(o,tmp.get(o));
	}
	}
	return newArrayTable;
	}

	/**
	* Returns the keys of the table, or <code>null</code> if there
	* are currently no bindings.
	* @param keys array of keys
	* @return an array of bindings
	*/
	public Object[] getKeys(Object[] keys) {
	if (table == null) {
	return null;
	}
	if (isArray()) {
	Object[] array = (Object[])table;
	if (keys == null) {
	keys = new Object[array.length / 2];
	}
	for (int i = 0, index = 0 ;i < array.length-1 ; i+=2,
	index++) {
	keys[index] = array[i];
	}
	} else {
	Hashtable<?,?> tmp = (Hashtable)table;
	Enumeration<?> enum_ = tmp.keys();
	int counter = tmp.size();
	if (keys == null) {
	keys = new Object[counter];
	}
	while (counter > 0) {
	keys[--counter] = enum_.nextElement();
	}
	}
	return keys;
	}

	/*
	* Returns true if the current storage mechanism is
	* an array of alternating key-value pairs.
	*/
	private boolean isArray(){
	return (table instanceof Object[]);
	}

	/*
	* Grows the storage from an array to a hashtable.
	*/
	private void grow() {
	Object[] array = (Object[])table;
	Hashtable<Object, Object> tmp = new Hashtable<Object, Object>(array.length/2);
	for (int i = 0; i<array.length; i+=2) {
	tmp.put(array[i], array[i+1]);
	}
	table = tmp;
	}

	/*
	* Shrinks the storage from a hashtable to an array.
	*/
	private void shrink() {
	Hashtable<?,?> tmp = (Hashtable)table;
	Object[] array = new Object[tmp.size()*2];
	Enumeration<?> keys = tmp.keys();
	int j = 0;

	while (keys.hasMoreElements()) {
	Object o = keys.nextElement();
	array[j] = o;
	array[j+1] = tmp.get(o);
	j+=2;
	}
	table = array;
	}
	}

Back to index...