/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common 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 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common 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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.util;
  
  import java.util.AbstractCollection;
  import java.util.AbstractSet;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  
  /**
   * A simple name-value list. Names are strings and values any Java objects
   * (where primitives are packed in their respective encapsulation objects).
   * Names and values are stored in arrays. The initial dimension of the array
   * can be specified or a default can be used ( <code>DEFAULT_CAPACITY =
   * 10</code> elements). If more elements are added, the arrays grow in
   * <code>DEFAULT_CAPACITY</code> increments. The addition is therefore a fast
   * operation,  if the arrays are not resized. The removal, on the other hand,
   * resizes the arrays each  time and is a much slower operation. Lookup of
   * value by name uses linear search and  string comparison. This object does
   * not allow duplicate name entries. If a duplicate  name is provided, the old
   * value will be overwritten and returned as a return  value from
   * <code>add</code> method.
   * 
   * <p>
   * This object is thread safe.
   * </p>
   * 
   * <p>
   * The primary purpose of this object is to store small (10 or less) name-value
   * pairs. In this case, the algorithms (including the linear search) are quite
   * effective. An example would be the use for passing the argument values to
   * the method calls.
   * </p>
   * 
   * <p>
   * <b>This class does preserve the order during insertion and deletion
   * operations.</b>
   * </p>
   * 
   * <p>
   * This class implements the collection <code>Map</code> interface.
   * </p>
   *
   * @author <a href="mailto:gasper.tkacik@cosylab.com">Gasper Tkacik</a>
   * @version $id$
   */
  public class NameValueList implements Map
  {
  	private String[] names = null;
  	private Object[] values = null;
  	private int ix = 0;
  	private KeySet keySet = new KeySet();
  	private EntrySet entrySet = new EntrySet();
  	private ValueCollection valueCollection = new ValueCollection();
  	private static final int DEFAULT_CAPACITY = 10;
  
  	private class EntrySet extends AbstractSet
  	{
  		/**
  		 * DOCUMENT ME!
  		 *
  		 * @return DOCUMENT ME!
  		 */
  		public Iterator iterator()
  		{
  			return new EntryIterator();
  		}
  
  		/**
  		 * DOCUMENT ME!
  		 *
  		 * @return DOCUMENT ME!
  		 */
  		public int size()
  		{
  			return NameValueList.this.size();
  		}
  	}
  
 	private class EntryIterator implements Iterator
 	{
 		private class Entry implements Map.Entry
 		{
 			private int ix = 0;
 
 			/**
 			 * Creates a new Entry object.
 			 *
 			 * @param ix
 			 */
 			public Entry(int ix)
 			{
 				this.ix = ix;
 			}
 
 			/**
 			 * DOCUMENT ME!
 			 *
 			 * @return DOCUMENT ME!
 			 */
 			public Object getValue()
 			{
 				return values[ix];
 			}
 
 			/**
 			 * DOCUMENT ME!
 			 *
 			 * @param value DOCUMENT ME!
 			 *
 			 * @return DOCUMENT ME!
 			 */
 			public Object setValue(Object value)
 			{
 				Object retVal = values[ix];
 				values[ix] = value;
 
 				return retVal;
 			}
 
 			/**
 			 * DOCUMENT ME!
 			 *
 			 * @return DOCUMENT ME!
 			 */
 			public Object getKey()
 			{
 				return names[ix];
 			}
 		}
 
 		private int ix = 0;
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public boolean hasNext()
 		{
 			if (ix < NameValueList.this.ix) {
 				return true;
 			} else {
 				return false;
 			}
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public Object next()
 		{
 			Entry retVal = new Entry(ix);
 			ix++;
 
 			return retVal;
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 */
 		public void remove()
 		{
 			NameValueList.this.remove(names[ix]);
 		}
 	}
 
 	private class KeySet extends AbstractSet
 	{
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public Iterator iterator()
 		{
 			return new KeyIterator();
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public int size()
 		{
 			return NameValueList.this.size();
 		}
 	}
 
 	private class KeyIterator implements Iterator
 	{
 		private int ix = 0;
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public boolean hasNext()
 		{
 			return (ix < NameValueList.this.ix);
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public Object next()
 		{
 			Object retVal = names[ix];
 			ix++;
 
 			return retVal;
 		}
 
 		/**
 		 * @see Iterator#remove()
 		 */
 		public void remove()
 		{
 			NameValueList.this.remove(names[ix]);
 		}
 	}
 
 	private class CollectionIterator implements Iterator
 	{
 		private int ix = 0;
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public boolean hasNext()
 		{
 			return (ix < NameValueList.this.ix);
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 */
 		public void remove()
 		{
 			NameValueList.this.remove(names[ix]);
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public Object next()
 		{
 			Object retVal = values[ix];
 			ix++;
 
 			return retVal;
 		}
 	}
 
 	private class ValueCollection extends AbstractCollection
 	{
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public Iterator iterator()
 		{
 			return new CollectionIterator();
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @return DOCUMENT ME!
 		 */
 		public int size()
 		{
 			return NameValueList.this.size();
 		}
 	}
 
 	/**
 	 * Creates a new instance of this object with the
 	 * <code>DEFAULT_CAPACITY</code> equal to 10.
 	 */
 	public NameValueList()
 	{
 		this(DEFAULT_CAPACITY);
 	}
 
 	/**
 	 * Creates a new instance of this object with the initial capacity
 	 * specified by the user.
 	 *
 	 * @param initialCapacity the size of the names and values array at
 	 *        construction
 	 */
 	public NameValueList(int initialCapacity)
 	{
 		assert (initialCapacity > 0);
 		names = new String[initialCapacity];
 		values = new Object[initialCapacity];
 	}
 
 	/**
 	 * Returns the actual number of entries stored in this data structure.
 	 *
 	 * @return int the size of the name-value list
 	 */
 	public synchronized int size()
 	{
 		return ix;
 	}
 
 	/**
 	 * Adds a new name-value pair. If the name already exists in the structure,
 	 * its value is replaced by the new value and the old value is returned as
 	 * a result of this method.
 	 *
 	 * @param name the name to store the value under
 	 * @param value a new value for the name
 	 *
 	 * @return Object the value that was previously stored under name
 	 *
 	 * @throws ClassCastException if parameter name is not of type
 	 *         <code>String</code>
 	 */
 	public synchronized Object put(Object name, Object value)
 	{
 		assert (name != null);
 
 		if (!(name instanceof String)) {
 			throw new ClassCastException("name !instanceof String");
 		}
 
 		String cast = (String)name;
 
 		int index = find(cast);
 
 		if (index != -1) {
 			Object retVal = values[index];
 			values[index] = value;
 
 			return retVal;
 		}
 
 		if (ix < names.length) {
 			names[ix] = cast;
 			values[ix] = value;
 			ix++;
 
 			return null;
 		} else {
 			resizeUp();
 
 			return put(cast, value);
 		}
 	}
 
 	/**
 	 * Removes a value stored under <code>name</code> and returns it. This
 	 * method resizes the arrays by decreasing them by 1.
 	 *
 	 * @param name the name of the value to remove
 	 *
 	 * @return Object the removed value or <code>null</code> if the value with
 	 *         the given name did not exist in the structure
 	 *
 	 * @throws ClassCastException if parameter name is not of type
 	 *         <code>String</code>
 	 */
 	public synchronized Object remove(Object name)
 	{
 		assert (name != null);
 
 		if (!(name instanceof String)) {
 			throw new ClassCastException("name !instanceof String");
 		}
 
 		int ix = find((String)name);
 
 		if (ix == -1) {
 			return null;
 		}
 
 		Object retVal = values[ix];
 		String[] newNames = new String[names.length - 1];
 		Object[] newValues = new Object[names.length - 1];
 		System.arraycopy(names, 0, newNames, 0, ix);
 		System.arraycopy(values, 0, newValues, 0, ix);
 		System.arraycopy(names, ix + 1, newNames, ix, names.length - ix - 1);
 		System.arraycopy(values, ix + 1, newValues, ix, names.length - ix - 1);
 		values = newValues;
 		names = newNames;
 		this.ix--;
 
 		return retVal;
 	}
 
 	/**
 	 * Returns an object stored under <code>name</code>.
 	 *
 	 * @param name the name to lookup
 	 *
 	 * @return Object the object with <code>name</code> or <code>null</code> if
 	 *         such  object does not exist
 	 *
 	 * @throws ClassCastException if parameter name is not of type
 	 *         <code>String</code>
 	 */
 	public synchronized Object get(Object name)
 	{
 		if (!(name instanceof String)) {
 			throw new ClassCastException("name !instanceof String");
 		}
 
 		assert (name != null);
 
 		int ix = find((String)name);
 
 		if (ix == -1) {
 			return null;
 		}
 
 		return values[ix];
 	}
 
 	/**
 	 * Returns an array of names stored in this data structure. This involves
 	 * creating a new string array, which may be modified by the user. All
 	 * values in this array are guaranteed to be non-<code>null</code>.
 	 *
 	 * @return String[] an array of names of this list
 	 */
 	public synchronized String[] getNames()
 	{
 		String[] array = new String[ix];
 		System.arraycopy(names, 0, array, 0, ix);
 
 		return array;
 	}
 
 	private synchronized int find(String name)
 	{
 		assert (name != null);
 
 		for (int i = 0; i < ix; i++) {
 			if (names[i] != null && names[i].equals(name)) {
 				return i;
 			}
 		}
 
 		return -1;
 	}
 
 	private synchronized void resizeUp()
 	{
 		if (ix == names.length) {
 			String[] newNames = new String[names.length + DEFAULT_CAPACITY];
 			Object[] newValues = new Object[names.length + DEFAULT_CAPACITY];
 			System.arraycopy(names, 0, newNames, 0, names.length);
 			System.arraycopy(values, 0, newValues, 0, names.length);
 			names = newNames;
 			values = newValues;
 		}
 	}
 
 	/**
 	 * Sets all elements to null, resets the current pointer to the initial
 	 * position thereby effectively removing all elements from this map.
 	 *
 	 * @see Map#clear()
 	 */
 	public synchronized void clear()
 	{
 		for (int i = 0; i < names.length; i++) {
 			names[i] = null;
 			values[i] = null;
 		}
 
 		ix = 0;
 	}
 
 	/**
 	 * Returns <code>true</code> if this object contains the name-value mapping
 	 * with the speficied <code>name</code>.
 	 *
 	 * @param name the name to lookup
 	 *
 	 * @return boolean <code>true</code> iff the mapping with the given name
 	 *         exists
 	 *
 	 * @throws NullPointerException if parameter name is <code>null</code>
 	 *
 	 * @see Map#containsKey(Object)
 	 */
 	public synchronized boolean containsKey(Object name)
 	{
 		if (name == null) {
 			throw new NullPointerException("name");
 		}
 
 		if (find((String)name) == -1) {
 			return false;
 		} else {
 			return true;
 		}
 	}
 
 	/**
 	 * Returns <code>true</code> if this map contains a given value. This is
 	 * determined as in <code>java.util.Map</code> specifications.
 	 *
 	 * @param value test if this map contains the value
 	 *
 	 * @return <code>true</code> iff the test succeeds
 	 *
 	 * @see Map#containsValue(Object)
 	 */
 	public synchronized boolean containsValue(Object value)
 	{
 		for (int i = 0; i < values.length; i++) {
 			if (value == null && values[i] == null) {
 				return true;
 			}
 
 			if (value != null && values[i] != null && value.equals(values[i])) {
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/**
 	 * Returns the set of entries, as described in
 	 * <code>java.util.Map.Entry</code>.
 	 *
 	 * @return Set a set of all entries
 	 *
 	 * @see Map#entrySet()
 	 */
 	public Set entrySet()
 	{
 		return entrySet;
 	}
 
 	/**
 	 * Returns <code>true</code> iff this map does not contain any name-value
 	 * pairs.
 	 *
 	 * @return boolean <code>true</code> iff empty
 	 *
 	 * @see Map#isEmpty()
 	 */
 	public boolean isEmpty()
 	{
 		return (ix == 0);
 	}
 
 	/**
 	 * Returns a set of all names.
 	 *
 	 * @return Set a set of all names
 	 *
 	 * @see Map#keySet()
 	 */
 	public Set keySet()
 	{
 		return keySet;
 	}
 
 	/**
 	 * Puts all nave-value pairs from provided Map to this Map.
 	 *
 	 * @param t a map argument with which to perform the union operation
 	 *
 	 * @see Map#putAll(Map)
 	 */
 	public synchronized void putAll(Map t)
 	{
 		Iterator it = t.entrySet().iterator();
 
 		while (it.hasNext()) {
 			Entry e = (Entry)it.next();
 			put(e.getKey(), e.getValue());
 		}
 	}
 
 	/**
 	 * Returns a collection of all values.
 	 *
 	 * @return a collection of all values
 	 *
 	 * @see Map#values()
 	 */
 	public Collection values()
 	{
 		return valueCollection;
 	}
 
 	/**
 	 * Lists all objects in this list by calling their <code>toString()</code>
 	 * methods.
 	 *
 	 * @return String the contents of this list
 	 */
 	public String toString()
 	{
 		StringBuffer sb = new StringBuffer(1000);
 		sb.append('{');
 
 		for (int i = 0; i < size(); i++) {
 			sb.append(' ');
 			sb.append(names[i]);
 			sb.append('=');
 			sb.append(values[i]);
 		}
 
 		sb.append(" }");
 
 		return new String(sb);
 	}
 }
 
 /* __oOo__ */