com.carrotsearch.hppcrt.FloatDoubleMap Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of hppcrt Show documentation

High Performance Primitive Collections Realtime (fork of HPPC from Carrotsearch) Fundamental data structures (maps, sets, lists, queues, heaps, sorts) generated for combinations of object and primitive types to conserve JVM memory and speed up execution. The Realtime fork intends to extend the existing collections, by tweaking to remove any dynamic allocations at runtime, and to obtain low variance execution times whatever the input nature.

There is a newer version: 0.7.5

Show newest version

package com.carrotsearch.hppcrt;

import com.carrotsearch.hppcrt.cursors.FloatDoubleCursor;

/**
 * An associative container with unique binding from keys to a single value.
 */
 @javax.annotation.Generated(
    date = "2016-01-27T20:51:54+0100",
    value = "KTypeVTypeMap.java") 
public interface FloatDoubleMap
extends FloatDoubleAssociativeContainer
{
    /**
     * Place a given key and value in the container.
     * @return Returns the value previously stored under the given key, if an equal key is already in the map and replaces the existing
     *  value only  with the argument value. If the given key was not already in the map,
     *  the given (key, value) pair is inserted in the map and the default value is returned.
     */
    double put(float key, double value);

    /**
     * Trove-inspired API method. An equivalent
     * of the following code:
     *      * if (!map.containsKey(key))
     *      map.put(key, value);
     * 
     * 
     * @param key The key of the value to check.
     * @param value The value to put if key does not exist.
     * @return true if key did not exist and value
     * was placed in the map.
     */
    boolean putIfAbsent(final float key, final double value);

     
    /**
     * If key exists, putValue is inserted into the map,
     * otherwise any existing value is incremented by additionValue.
     * 
     * @param key
     *          The key of the value to adjust.
     * @param putValue
     *          The value to put if key does not exist.
     * @param incrementValue
     *          The value to add to the existing value if key exists.
     * @return Returns the current value associated with key (after
     *         changes).
     */
    double putOrAdd(float key, double putValue, double additionValue);

      

      
    /**
     * An equivalent of calling
     * 
     *      * putOrAdd(key, additionValue, additionValue);
     * 
     * 
     * @param key
     *          The key of the value to adjust.
     * @param additionValue
     *          The value to put or add to the existing value if key
     *          exists.
     * @return Returns the current value associated with key (after
     *         changes).
     */
    double addTo(float key, double additionValue);

      

    /**
     * @return Returns the value associated with the given key, or the default value
     * if the key is not associated with any value.
     *
     */
    double get(float key);

    /**
     * Puts all keys from another container to this map, replacing the values
     * of existing keys, if such keys are present.
     * 
     * @return Returns the number of keys added to the map as a result of this
     * call (not previously present in the map). Values of existing keys are overwritten.
     */
    int putAll(FloatDoubleAssociativeContainer container);

    /**
     * Puts all keys from an iterable cursor to this map, replacing the values
     * of existing keys, if such keys are present.
     * 
     * @return Returns the number of keys added to the map as a result of this
     * call (not previously present in the map). Values of existing keys are overwritten.
     */
    int putAll(Iterable iterable);

    /**
     * Remove the (key, value) pair associated with the given key, and returns the assocaited value.
     * The default value is returned if the key did not exist in the map.
     * @param key
     */
    double remove(float key);

    /**
     * Clear all keys and values in the container.
     */
    void clear();

    /**
     * Returns the "default value" value used in containers methods returning
     * "default value"
     */
    double getDefaultValue();

    /**
     * Set the "default value" value to be used in containers methods returning
     * "default value"
     */
    void setDefaultValue(final double defaultValue);
}