gnu.trove.map.TLongFloatMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
High performance collections for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2009, Rob Eden 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;


//////////////////////////////////////////////////
// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
//////////////////////////////////////////////////

import gnu.trove.function.*;
import gnu.trove.iterator.*;
import gnu.trove.procedure.*;
import gnu.trove.set.*;
import gnu.trove.TFloatCollection;

import java.util.Map;
import java.io.Serializable;


/**
 * Interface for a primitive map of long keys and float values.
 */
public interface TLongFloatMap {
    /**
     * Returns the value that will be returned from {@link #get} or {@link #put} if no
     * entry exists for a given key. The default value is generally zero, but can be
     * configured during construction of the collection.
     *
     * @return the value that represents a null key in this collection.
     */
    public long getNoEntryKey();


    /**
     * Returns the value that will be returned from {@link #get} or {@link #put} if no
     * entry exists for a given key. The default value is generally zero, but can be
     * configured during construction of the collection.
     *
     * @return the value that represents a null value in this collection.
     */
    public float getNoEntryValue();


    /**
     * Inserts a key/value pair into the map.
     *
     * @return the previous value associated with key, or the "no entry" value
     *         if none was found (see {@link #getNoEntryValue}).
     */
    public float put( long key, float value );


    /**
     * Inserts a key/value pair into the map if the specified key is not already
     * associated with a value.
     *
     * @return the previous value associated with key, or the "no entry" value
     *         if none was found (see {@link #getNoEntryValue}).
     */
    public float putIfAbsent( long key, float value );


    /**
     * 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.
     */
    public void putAll( Map map );


    /**
     * 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.
     */
    public void putAll( TLongFloatMap map );


    /**
     * Retrieves the value for key.
     *
     * @return the previous value associated with key, or the "no entry" value
     *         if none was found (see {@link #getNoEntryValue}).
     */
    public float get( long key );


    /**
     * Empties the map.
     */
    public void clear();


    /**
      * Returns true if this map contains no key-value mappings.
      *
      * @return true if this map contains no key-value mappings
      */
     public boolean isEmpty();


    /**
     * Deletes a key/value pair from the map.
     *
     * @param key an long value
     *
     * @return the previous value associated with key, or the "no entry" value
     *         if none was found (see {@link #getNoEntryValue}).
     */
    public float remove( long key );


    /**
     * Returns an int value that is the number of elements in the map.
     *
     * @return an int value that is the number of elements in the map.
     */
    public int size();


    /**
     * Returns the keys of the map as a TLongSet
     *
     * @return the keys of the map as a TLongSet
     */
    public TLongSet keySet();


    /**
     * Returns the keys of the map as an array of long values.
     *
     * @return the keys of the map as an array of long values.
     */
    public long[] keys();


    /**
     * Returns the keys of the map.
     *
     * @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.
     */
    public long[] keys( long[] array );


    /**
     * Returns the values of the map as a TFloatCollection
     *
     * @return the values of the map as a TFloatCollection
     */
    public TFloatCollection valueCollection();


    /**
     * Returns the values of the map as an array of #e# values.
     *
     * @return the values of the map as an array of #e# values.
     */
    public float[] values();


    /**
     * Returns the values of the map using an existing array.
     *
     * @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 #e# values.
     */
    public float[] values( float[] array );


    /**
     * Checks for the presence of val in the values of the map.
     */
    public boolean containsValue( float val );


    /**
     * Checks for the present of key in the keys of the map.
     */
    public boolean containsKey( long key );


    /**
     * @return a TLongFloatIterator with access to this map's keys and values
     */
    public TLongFloatIterator iterator();


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


    /**
     * Executes procedure for each value in the map.
     *
     * @param procedure a T#F#Procedure value
     * @return false if the loop over the values terminated because
     *               the procedure returned false for some value.
     */
    public boolean forEachValue( TFloatProcedure procedure );


    /**
     * Executes procedure for each key/value entry in the
     * map.
     *
     * @param procedure a TOLongFloatProcedure value
     * @return false if the loop over the entries terminated because
     *               the procedure returned false for some entry.
     */
    public boolean forEachEntry( TLongFloatProcedure procedure );


    /**
     * Transform the values in this map using function.
     *
     * @param function a TFloatFunction value
     */
    public void transformValues( TFloatFunction 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( TLongFloatProcedure procedure );


    /**
     * 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( long key );


    /**
     * 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( long key, float amount );


    /**
     * Adjusts the primitive value mapped to the key if the key is present in the map.
     * Otherwise, the put_amount is put in the map.
     *
     * @param key the key of the value to increment
     * @param adjust_amount the amount to adjust the value by
     * @param put_amount the value put into the map if the key is not present
     *
     * @return the value present in the map after the adjustment or put operation
     */
    public float adjustOrPutValue( long key, float adjust_amount, float put_amount );
}