content: ///////////////////////////////////////////////////////////////////////////////
  // Copyright (c) 2001, Eric D. Friedman All Rights Reserved.
  // Copyright (c) 2009, Rob Eden All Rights Reserved.
  // Copyright (c) 2009, Jeff Randall 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.map;
  
  import gnu.trove.iterator.TFloatObjectIterator;
  import gnu.trove.procedure.TFloatProcedure;
  import gnu.trove.procedure.TObjectProcedure;
  import gnu.trove.procedure.TFloatObjectProcedure;
  import gnu.trove.function.TObjectFunction;
  import gnu.trove.set.TFloatSet;
  
  import java.util.Collection;
  import java.util.Map;
  
  
  //////////////////////////////////////////////////
  // THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
  //////////////////////////////////////////////////
  
  
  /**
   * Interface for a primitive map of float keys and Object values.
   */
  public interface TFloatObjectMap<V> {
  
  // Query Operations
  
      /**
       * Returns the value that represents null in the {@link #keySet()}.
       * The default value is generally zero, but can be changed during
       * construction of the collection.
       *
       * @return the value that represents a null value in this collection.
       */
      float getNoEntryKey();
  
  
      /**
       * Returns the number of key-value mappings in this map.  If the
       * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
       * <tt>Integer.MAX_VALUE</tt>.
       *
       * @return the number of key-value mappings in this map
       */
      int size();
  
  
      /**
       * Returns <tt>true</tt> if this map contains no key-value mappings.
       *
       * @return <tt>true</tt> if this map contains no key-value mappings
       */
      boolean isEmpty();
  
  
      /**
       * Returns <tt>true</tt> if this map contains a mapping for the specified
       * key.  More formally, returns <tt>true</tt> if and only if
       * this map contains a mapping for a key <tt>k</tt> such that
       * <tt>key.equals(k)</tt>.  (There can be at most one such mapping.)
       *
       * @param key key whose presence in this map is to be tested
       * @return <tt>true</tt> if this map contains a mapping for the specified
       *         key
       * @throws ClassCastException if the key is of an inappropriate type for
       *         this map (optional)
       * @throws NullPointerException if the specified key is null and this map
       *         does not permit null keys (optional)
       */
      boolean containsKey( float key );
  
  
      /**
       * Returns <tt>true</tt> if this map maps one or more keys to the
       * specified value.  More formally, returns <tt>true</tt> if and only if
       * this map contains at least one mapping to a value <tt>v</tt> such that
       * <tt>(value==null ? v==null : value.equals(v))</tt>.  This operation
       * will probably require time linear in the map size for most
       * implementations of the <tt>Map</tt> interface.
       *
       * @param value value whose presence in this map is to be tested
       * @return <tt>true</tt> if this map maps one or more keys to the
       *         specified value
       * @throws ClassCastException if the value is of an inappropriate type for
       *         this map (optional)
       * @throws NullPointerException if the specified value is null and this
       *         map does not permit null values (optional)
       */
      boolean containsValue( Object value );
  
  
      /**
       * Returns the value to which the specified key is mapped,
       * or {@code null} if this map contains no mapping for the key.
       *
       * <p>More formally, if this map contains a mapping from a key
       * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
       * key.equals(k))}, then this method returns {@code v}; otherwise
       * it returns {@code null}.  (There can be at most one such mapping.)
       *
       * <p>If this map permits null values, then a return value of
       * {@code null} does not <i>necessarily</i> indicate that the map
       * contains no mapping for the key; it's also possible that the map
       * explicitly maps the key to {@code null}.  The {@link #containsKey
       * containsKey} operation may be used to distinguish these two cases.
       *
       * @param key the key whose associated value is to be returned
       * @return the <tt>float</tt> value to which the specified key is mapped, or
       *         {@code null} if this map contains no mapping for the key
       * @throws ClassCastException if the key is of an inappropriate type for
       *         this map (optional)
       * @throws NullPointerException if the specified key is null and this map
       *         does not permit null keys (optional)
       */
      V get( float key );
  
  
      // Modification Operations
  
      /**
       * Associates the specified value with the specified key in this map
       * (optional operation).  If the map previously contained a mapping for
       * the key, the old value is replaced by the specified value.  (A map
       * <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and only
       * if {@link #containsKey(float) m.containsKey(k)} would return
       * <tt>true</tt>.)
       *
       * @param key key with which the specified value is to be associated
       * @param value an <tt>float</tt> value value to be associated with the specified key
       * @return the previous value associated with <tt>key</tt>, or
       *         <tt>no_entry_value</tt> if there was no mapping for <tt>key</tt>.
       *         (A <tt>no_entry_value</tt> return can also indicate that the map
       *         previously associated <tt>null</tt> with <tt>key</tt>,
       *         if the implementation supports <tt>null</tt> values.)
       * @throws UnsupportedOperationException if the <tt>put</tt> operation
       *         is not supported by this map
       * @throws ClassCastException if the class of the specified key or value
       *         prevents it from being stored in this map
       * @throws NullPointerException if the specified key or value is null
       *         and this map does not permit null keys or values
       * @throws IllegalArgumentException if some property of the specified key
       *         or value prevents it from being stored in this map
       * @see	#getNoEntryKey()
       */
      V put( float key, V value);
  
  
      /**
       * Inserts a key/value pair into the map if the specified key is not already
       * associated with a value.
       *
       * @param key key with which the specified value is to be associated
       * @param value an <tt>float</tt> value to be associated with the specified key
       *
       * @return the previous value associated with <tt>key</tt>, or null
       *         if none was found.
       */
      V putIfAbsent( float key, V value );
  
  
      /**
       * Removes the mapping for a key from this map if it is present
       * (optional operation).   More formally, if this map contains a mapping
       * from key <tt>k</tt> to value <tt>v</tt> such that
       * <code>key.equals(k)</code>, that mapping
       * is removed.  (The map can contain at most one such mapping.)
       *
       * <p>Returns the value to which this map previously associated the key,
       * or <tt>null</tt> if the map contained no mapping for the key.
       *
       * <p>If this map permits null values, then a return value of
       * <tt>null</tt> does not <i>necessarily</i> indicate that the map
       * contained no mapping for the key; it's also possible that the map
       * explicitly mapped the key to <tt>null</tt>.
       *
       * <p>The map will not contain a mapping for the specified key once the
       * call returns.
       *
       * @param key key whose mapping is to be removed from the map
       * @return the previous <tt>float</tt> value associated with <tt>key</tt>, or
       *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
       * @throws UnsupportedOperationException if the <tt>remove</tt> operation
       *         is not supported by this map
       * @throws ClassCastException if the key is of an inappropriate type for
       *         this map (optional)
       * @throws NullPointerException if the specified key is null and this
       *         map does not permit null keys (optional)
       */
      V remove( float key );
  
  
      // Bulk Operations
  
      /**
       * Copies all of the mappings from the specified map to this map
       * (optional operation).  The effect of this call is equivalent to that
       * of calling {@link #put(float,Object) put(k, v)} on this map once
       * for each mapping from key <tt>k</tt> to value <tt>v</tt> in the
       * specified map.  The behavior of this operation is undefined if the
       * specified map is modified while the operation is in progress.
       *
       * @param m mappings to be stored in this map
       * @throws UnsupportedOperationException if the <tt>putAll</tt> operation
       *         is not supported by this map
       * @throws ClassCastException if the class of a key or value in the
       *         specified map prevents it from being stored in this map
       * @throws NullPointerException if the specified map is null, or if
       *         this map does not permit null keys or values, and the
       *         specified map contains null keys or values
       * @throws IllegalArgumentException if some property of a key or value in
       *         the specified map prevents it from being stored in this map
       */
      void putAll( Map<? extends Float, ? extends V> m);
  
  
      /**
       * Put all the entries from the given map into this map.
       *
       * @param map   The map from which entries will be obtained to put into this map.
       */
      void putAll( TFloatObjectMap<? extends V> map );
  
  
      /**
       * Removes all of the mappings from this map (optional operation).
       * The map will be empty after this call returns.
       *
       * @throws UnsupportedOperationException if the <tt>clear</tt> operation
       *         is not supported by this map
       */
      void clear();
  
  
      // Views
  
      /**
       * Returns a {@link TFloatSet} view of the keys contained in this map.
       * The set is backed by the map, so changes to the map are
       * reflected in the set, and vice-versa.  If the map is modified
       * while an iteration over the set is in progress (except through
       * the iterator's own <tt>remove</tt> operation), the results of
       * the iteration are undefined.  The set supports element removal,
       * which removes the corresponding mapping from the map, via the
       * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
       * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
       * operations.  It does not support the <tt>add</tt> or <tt>addAll</tt>
       * operations.
       *
       * @return a set view of the keys contained in this map
       */
      TFloatSet keySet();
  
  
      /**
       * Returns a copy of the keys of the map as an array.
       * Changes to the array of keys will not be reflected in the map
       * nor vice-versa.
       *
       * @return a copy of the keys of the map as an array.
       */
      float[] keys();
  
  
      /**
       * Returns a copy of the keys of the map as an array.
       * Changes to the array of keys will not be reflected in the map
       * nor vice-versa.
       *
       * @param array   the array into which the elements of the list are to be stored,
       *                if it is big enough; otherwise, a new array of the same type is
       *                allocated for this purpose.
       * @return the keys of the map as an array.
       */
      float[] keys( float[] array );
  
  
  
      /**
       * Returns a {@link Collection} view of the values contained in this map.
       * The collection is backed by the map, so changes to the map are
       * reflected in the collection, and vice-versa.  If the map is
       * modified while an iteration over the collection is in progress
       * (except through the iterator's own <tt>remove</tt> operation),
       * the results of the iteration are undefined.  The collection
       * supports element removal, which removes the corresponding
       * mapping from the map, via the <tt>Iterator.remove</tt>,
       * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
       * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not
       * support the <tt>add</tt> or <tt>addAll</tt> operations.
       *
       * @return a collection view of the values contained in this map
       */
      Collection<V> valueCollection();
  
  
      /**
       * Returns the values of the map as an Object array. Note that the array returned
       * is typed as an Object[] and may not be cast to a more specific type. See
       * {@link #values(V[])} for a version which allows specifically typed arrays.
       * Changes to the array of values will not be reflected in the map
       * nor vice-versa.
       *
       * @return the values of the map as an array of <tt>float</tt> values.
       */
      Object[] values();
  
  
      /**
       * Returns the values of the map using an existing array.
       * Changes to the array of values will not be reflected in the map
       * nor vice-versa.
       *
       * @param array   the array into which the elements of the list are to be stored,
       *                if it is big enough; otherwise, a new array of the same type is
       *                allocated for this purpose.
       * @return the values of the map as an array of <tt>float</tt> values.
       */
      V[] values( V[] array );
  
  
      /**
       * Returns a <tt>TFloatObjectIterator</tt> with access to this map's keys and values.
       *
       * @return a <tt>TFloatObjectIterator</tt> with access to this map's keys and values.
       */
      public TFloatObjectIterator<V> iterator();
  
  
      /**
       * Executes <tt>procedure</tt> for each key in the map.
       *
       * @param procedure a <code>TObjectProcedure</code> value
       * @return false if the loop over the keys terminated because
       *         the procedure returned false for some key.
       */
      public boolean forEachKey( TFloatProcedure procedure );
  
  
      /**
       * Executes <tt>procedure</tt> for each value in the map.
       *
       * @param procedure a <code>TObjectProcedure</code> value
       * @return false if the loop over the values terminated because
       *         the procedure returned false for some value.
       */
      public boolean forEachValue( TObjectProcedure<? super V> procedure );
  
  
      /**
       * Executes <tt>procedure</tt> for each key/value entry in the
       * map.
       *
       * @param procedure a <code>TFloatObjectProcedure</code> value
       * @return false if the loop over the entries terminated because
       *         the procedure returned false for some entry.
       */
      public boolean forEachEntry( TFloatObjectProcedure<? super V> procedure );
  
  
      /**
       * Transform the values in this map using <tt>function</tt>.
       *
       * @param function a <code>TObjectFunction</code> value
       */
      public void transformValues( TObjectFunction<V,V> function );
  
  
      /**
       * 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( TFloatObjectProcedure<? super V> procedure );
  
  
      // Comparison and hashing
  
      /**
       * Compares the specified object with this map for equality.  Returns
       * <tt>true</tt> if the given object is also a map and the two maps
       * represent the same mappings.  More formally, two maps <tt>m1</tt> and
       * <tt>m2</tt> represent the same mappings if
       * <tt>m1.entrySet().equals(m2.entrySet())</tt>.  This ensures that the
       * <tt>equals</tt> method works properly across different implementations
       * of the <tt>Map</tt> interface.
       *
       * @param o object to be compared for equality with this map
       * @return <tt>true</tt> if the specified object is equal to this map
       */
      boolean equals( Object o );
  
  
      /**
       * Returns the hash code value for this map.  The hash code of a map is
       * defined to be the sum of the hash codes of each entry in the map's
       * <tt>entrySet()</tt> view.  This ensures that <tt>m1.equals(m2)</tt>
       * implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
       * <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
       * {@link Object#hashCode}.
       *
       * @return the hash code value for this map
       
       * @see Object#equals(Object)
       * @see #equals(Object)
       */
      int hashCode();
  }
  