///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2001, Eric D. Friedman All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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 Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
///////////////////////////////////////////////////////////////////////////////

package gnu.trove;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * An open addressed Map implementation for Object keys and float values.
 *
 * Created: Sun Nov  4 08:52:45 2001
 *
 * @author Eric D. Friedman
 * @version $Id: TObjectFloatHashMap.java,v 1.13 2003/03/23 04:06:59 ericdf Exp $
 */
public class TObjectFloatHashMap extends TObjectHash implements Serializable {

    /** the values of the map */
    protected transient float[] _values;

    /**
     * Creates a new TObjectFloatHashMap instance with the default
     * capacity and load factor.
     */
    public TObjectFloatHashMap() {
        super();
    }

    /**
     * Creates a new TObjectFloatHashMap instance with a prime
     * capacity equal to or greater than initialCapacity and
     * with the default load factor.
     *
     * @param initialCapacity an int value
     */
    public TObjectFloatHashMap(int initialCapacity) {
        super(initialCapacity);
    }

    /**
     * Creates a new TObjectFloatHashMap instance with a prime
     * capacity equal to or greater than initialCapacity and
     * with the specified load factor.
     *
     * @param initialCapacity an int value
     * @param loadFactor a float value
     */
    public TObjectFloatHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
    }

    /**
     * Creates a new TObjectFloatHashMap instance with the default
     * capacity and load factor.
     * @param strategy used to compute hash codes and to compare keys.
     */
    public TObjectFloatHashMap(TObjectHashingStrategy strategy) {
        super(strategy);
    }

    /**
     * Creates a new TObjectFloatHashMap instance whose capacity
     * is the next highest prime above initialCapacity + 1
     * unless that value is already prime.
     *
     * @param initialCapacity an int value
     * @param strategy used to compute hash codes and to compare keys.
     */
    public TObjectFloatHashMap(int initialCapacity, TObjectHashingStrategy strategy) {
        super(initialCapacity, strategy);
    }

    /**
     * Creates a new TObjectFloatHashMap instance with a prime
     * value at or near the specified capacity and load factor.
     *
     * @param initialCapacity used to find a prime capacity for the table.
     * @param loadFactor used to calculate the threshold over which
     * rehashing takes place.
     * @param strategy used to compute hash codes and to compare keys.
     */
    public TObjectFloatHashMap(int initialCapacity, float loadFactor, TObjectHashingStrategy strategy) {
        super(initialCapacity, loadFactor, strategy);
    }

    /**
     * @return an iterator over the entries in this map
     */
    public TObjectFloatIterator iterator() {
        return new TObjectFloatIterator(this);
    }

    /**
     * initializes the hashtable to a prime capacity which is at least
     * initialCapacity + 1.  
     *
     * @param initialCapacity an int value
     * @return the actual capacity chosen
     */
    protected int setUp(int initialCapacity) {
        int capacity;

        capacity = super.setUp(initialCapacity);
        _values = new float[capacity];
        return capacity;
    }

    /**
     * Inserts a key/value pair into the map.
     *
     * @param key an Object value
     * @param value an float value
     * @return the previous value associated with key,
     * or null if none was found.
     */
    public float put(Object key, float value) {
        float previous = (float)0;
        int index = insertionIndex(key);
        boolean isNewMapping = true;
        if (index < 0) {
            index = -index -1;
            previous = _values[index];
            isNewMapping = false;
        }
        Object oldKey = _set[index];
        _set[index] = key;
        _values[index] = value;

        if (isNewMapping) {
            postInsertHook(oldKey == null);
        }
        return previous;
    }

    /**
     * rehashes the map to the new capacity.
     *
     * @param newCapacity an int value
     */
    protected void rehash(int newCapacity) {
        int oldCapacity = _set.length;
        Object oldKeys[] = _set;
        float oldVals[] = _values;

        _set = new Object[newCapacity];
        _values = new float[newCapacity];

        for (int i = oldCapacity; i-- > 0;) {
          if(oldKeys[i] != null && oldKeys[i] != REMOVED) {
                Object o = oldKeys[i];
                int index = insertionIndex(o);
                if (index < 0) {
                    throwObjectContractViolation(_set[(-index -1)], o);
                }
                _set[index] = o;
                _values[index] = oldVals[i];
            }
        }
    }

    /**
     * retrieves the value for key
     *
     * @param key an Object value
     * @return the value of key or null if no such mapping exists.
     */
    public float get(Object key) {
        int index = index(key);
        return index < 0 ? (float)0 : _values[index];
    }

    /**
     * Empties the map.
     *
     */
    public void clear() {
        super.clear();
        Object[] keys = _set;
        float[] vals = _values;

        for (int i = keys.length; i-- > 0;) {
            keys[i] = null;
            vals[i] = (float)0;
        }
    }

    /**
     * Deletes a key/value pair from the map.
     *
     * @param key an Object value
     * @return an float value
     */
    public float remove(Object key) {
        float prev = (float)0;
        int index = index(key);
        if (index >= 0) {
            prev = _values[index];
            removeAt(index);    // clear key,state; adjust size
        }
        return prev;
    }

    /**
     * Compares this map with another map for equality of their stored
     * entries.
     *
     * @param other an Object value
     * @return a boolean value
     */
    public boolean equals(Object other) {
        if (! (other instanceof TObjectFloatHashMap)) {
            return false;
        }
        TObjectFloatHashMap that = (TObjectFloatHashMap)other;
        if (that.size() != this.size()) {
            return false;
        }
        return forEachEntry(new EqProcedure(that));
    }

    private static final class EqProcedure implements TObjectFloatProcedure {
        private final TObjectFloatHashMap _otherMap;

        EqProcedure(TObjectFloatHashMap otherMap) {
            _otherMap = otherMap;
        }

        public final boolean execute(Object key, float value) {
            int index = _otherMap.index(key);
            if (index >= 0 && eq(value, _otherMap.get(key))) {
                return true;
            }
            return false;
        }

        /**
         * Compare two floats for equality.
         */
        private final boolean eq(float v1, float v2) {
            return v1 == v2;
        }

    }

    /**
     * removes the mapping at index from the map.
     *
     * @param index an int value
     */
    protected void removeAt(int index) {
        super.removeAt(index);  // clear key, state; adjust size
        _values[index] = (float)0;
    }

    /**
     * Returns the values of the map.
     *
     * @return a Collection value
     */
    public float[] getValues() {
        float[] vals = new float[size()];
        float[] v = _values;
        Object[] keys = _set;

        for (int i = v.length, j = 0; i-- > 0;) {
          if (keys[i] != null && keys[i] != REMOVED) {
            vals[j++] = v[i];
          }
        }
        return vals;
    }

    /**
     * returns the keys of the map.
     *
     * @return a Set value
     */
    public Object[] keys() {
        Object[] keys = new Object[size()];
        Object[] k = _set;

        for (int i = k.length, j = 0; i-- > 0;) {
          if (k[i] != null && k[i] != REMOVED) {
            keys[j++] = k[i];
          }
        }
        return keys;
    }

    /**
     * checks for the presence of val in the values of the map.
     *
     * @param val an float value
     * @return a boolean value
     */
    public boolean containsValue(float val) {
        Object[] keys = _set;
        float[] vals = _values;

        for (int i = vals.length; i-- > 0;) {
            if (keys[i] != null && keys[i] != REMOVED && val == vals[i]) {
                return true;
            }
        }
        return false;
    }


    /**
     * checks for the present of key in the keys of the map.
     *
     * @param key an Object value
     * @return a boolean value
     */
    public boolean containsKey(Object key) {
        return contains(key);
    }

    /**
     * Executes procedure for each key in the map.
     *
     * @param procedure a TObjectProcedure value
     * @return false if the loop over the keys terminated because
     * the procedure returned false for some key.
     */
    public boolean forEachKey(TObjectProcedure procedure) {
        return forEach(procedure);
    }

    /**
     * Executes procedure for each value in the map.
     *
     * @param procedure a TFloatProcedure value
     * @return false if the loop over the values terminated because
     * the procedure returned false for some value.
     */
    public boolean forEachValue(TFloatProcedure procedure) {
        Object[] keys = _set;
        float[] values = _values;
        for (int i = values.length; i-- > 0;) {
            if (keys[i] != null && keys[i] != REMOVED
                && ! procedure.execute(values[i])) {
                return false;
            }
        }
        return true;
    }

    /**
     * Executes procedure for each key/value entry in the
     * map.
     *
     * @param procedure a TOObjectFloatProcedure value
     * @return false if the loop over the entries terminated because
     * the procedure returned false for some entry.
     */
    public boolean forEachEntry(TObjectFloatProcedure procedure) {
        Object[] keys = _set;
        float[] values = _values;
        for (int i = keys.length; i-- > 0;) {
            if (keys[i] != null
                && keys[i] != REMOVED
                && ! procedure.execute(keys[i],values[i])) {
                return false;
            }
        }
        return true;
    }

    /**
     * Retains only those entries in the map for which the procedure
     * returns a true value.
     *
     * @param procedure determines which entries to keep
     * @return true if the map was modified.
     */
    public boolean retainEntries(TObjectFloatProcedure procedure) {
        boolean modified = false;
        Object[] keys = _set;
        float[] values = _values;
        for (int i = keys.length; i-- > 0;) {
            if (keys[i] != null
                && keys[i] != REMOVED
                && ! procedure.execute(keys[i],values[i])) {
                removeAt(i);
                modified = true;
            }
        }
        return modified;
    }

    /**
     * Transform the values in this map using function.
     *
     * @param function a TFloatFunction value
     */
    public void transformValues(TFloatFunction function) {
        Object[] keys = _set;
        float[] values = _values;
        for (int i = values.length; i-- > 0;) {
            if (keys[i] != null && keys[i] != REMOVED) {
                values[i] = function.execute(values[i]);
            }
        }
    }

    /**
     * Increments the primitive value mapped to key by 1
     *
     * @param key the key of the value to increment
     * @return true if a mapping was found and modified.
     */
    public boolean increment(Object key) {
        return adjustValue(key, (float)1);
    }

    /**
     * Adjusts the primitive value mapped to key.
     *
     * @param key the key of the value to increment
     * @param amount the amount to adjust the value by.
     * @return true if a mapping was found and modified.
     */
    public boolean adjustValue(Object key, float amount) {
        int index = index(key);
        if (index < 0) {
            return false;
        } else {
            _values[index] += amount;
            return true;
        }
    }


    private void writeObject(ObjectOutputStream stream)
        throws IOException {
        stream.defaultWriteObject();

        // number of entries
        stream.writeInt(_size);

        SerializationProcedure writeProcedure = new SerializationProcedure(stream);
        if (! forEachEntry(writeProcedure)) {
            throw writeProcedure.exception;
        }
    }

    private void readObject(ObjectInputStream stream)
        throws IOException, ClassNotFoundException {
        stream.defaultReadObject();

        int size = stream.readInt();
        setUp(size);
        while (size-- > 0) {
            Object key = stream.readObject();
            float val = stream.readFloat();
            put(key, val);
        }
    }
} // TObjectFloatHashMap