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

Go to download
package com.carrotsearch.hppcrt;

import com.carrotsearch.hppcrt.cursors.ByteDoubleCursor;

/**
 * An associative container with unique binding from keys to a single value.
 */
 @javax.annotation.Generated(
    date = "2016-01-30T23:09:29+0100",
    value = "KTypeVTypeMap.java") 
public interface ByteDoubleMap
extends ByteDoubleAssociativeContainer
{
    /**
     * 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(byte 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 byte 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(byte 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(byte 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(byte 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(ByteDoubleAssociativeContainer 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(byte 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);
}