gnu.trove.map.TDoubleDoubleMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of trove4j Show documentation
Show all versions of trove4j Show documentation
The Trove library provides high speed regular and primitive
collections for Java.
///////////////////////////////////////////////////////////////////////////////
// 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.TDoubleCollection;
import java.util.Map;
import java.io.Serializable;
/**
* Interface for a primitive map of double keys and double values.
*/
public interface TDoubleDoubleMap {
/**
* 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
* changed during construction of the collection.
*
* @return the value that represents a null key in this collection.
*/
public double 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
* changed during construction of the collection.
*
* @return the value that represents a null value in this collection.
*/
public double getNoEntryValue();
/**
* Inserts a key/value pair into the map.
*
* @param key an double value
* @param value an double value
*
* @return the previous value associated with key, or the "no entry" value
* if none was found (see {@link #getNoEntryValue}).
*/
public double put( double key, double value );
/**
* Inserts a key/value pair into the map if the specified key is not already
* associated with a value.
*
* @param key an double value
* @param value an double value
*
* @return the previous value associated with key, or the "no entry" value
* if none was found (see {@link #getNoEntryValue}).
*/
public double putIfAbsent( double key, double 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( TDoubleDoubleMap map );
/**
* Retrieves the value for key
*
* @param key an double value
*
* @return the previous value associated with key, or the "no entry" value
* if none was found (see {@link #getNoEntryValue}).
*/
public double get( double 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 double value
*
* @return the previous value associated with key, or the "no entry" value
* if none was found (see {@link #getNoEntryValue}).
*/
public double remove( double 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 TDoubleSet
*
* @return the keys of the map as a TDoubleSet
*/
public TDoubleSet keySet();
/**
* Returns the keys of the map as an array of double values.
*
* @return the keys of the map as an array of double values.
*/
public double[] 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 double[] keys( double[] array );
/**
* Returns the values of the map as a TDoubleCollection
*
* @return the values of the map as a TDoubleCollection
*/
public TDoubleCollection 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 double[] 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 double[] values( double[] array );
/**
* Checks for the presence of val in the values of the map.
*
* @param val an double value
* @return a boolean value
*/
public boolean containsValue( double val );
/**
* Checks for the present of key in the keys of the map.
*
* @param key an double value
* @return a boolean value
*/
public boolean containsKey( double key );
/**
* @return a TDoubleDoubleIterator with access to this map's keys and values
*/
public TDoubleDoubleIterator iterator();
/**
* Executes procedure for each key in the map.
*
* @param procedure a TDoubleProcedure value
* @return false if the loop over the keys terminated because
* the procedure returned false for some key.
*/
public boolean forEachKey( TDoubleProcedure 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( TDoubleProcedure procedure );
/**
* Executes procedure for each key/value entry in the
* map.
*
* @param procedure a TODoubleDoubleProcedure value
* @return false if the loop over the entries terminated because
* the procedure returned false for some entry.
*/
public boolean forEachEntry( TDoubleDoubleProcedure procedure );
/**
* Transform the values in this map using function.
*
* @param function a TDoubleFunction value
*/
public void transformValues( TDoubleFunction 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( TDoubleDoubleProcedure 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( double 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( double key, double amount );
/**
* Adjusts the primitive value mapped to the key if the key is present in the map.
* Otherwise, the initial_value 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 initial present
*
* @return the value present in the map after the adjustment or put operation
*/
public double adjustOrPutValue( double key, double adjust_amount, double put_amount );
}