org.eclipse.collections.api.map.primitive.MutableIntObjectMap Maven / Gradle / Ivy
/*
* Copyright (c) 2022 Goldman Sachs.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.api.map.primitive;
import org.eclipse.collections.api.IntIterable;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function0;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.primitive.IntToObjectFunction;
import org.eclipse.collections.api.block.predicate.primitive.IntObjectPredicate;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.tuple.primitive.IntObjectPair;
/**
* This file was automatically generated from template file mutablePrimitiveObjectMap.stg.
*
* @since 3.0.
*/
public interface MutableIntObjectMap extends IntObjectMap, MutablePrimitiveObjectMap
{
/**
* Associates a value with the specified key. If a value is already associated
* with the key in this map, it will be replaced with {@code value}.
* @param key the key
* @param value the value to associate with {@code value}
* @return the value previously associated with {@code key} if one existed, or
* {@code null} if not
*/
V put(int key, V value);
/**
* This method allows MutableIntObjectMap the ability to add an element in the form of {@code IntObjectPair}.
*
* @see #put(int, Object)
* @since 9.1.0
*/
default V putPair(IntObjectPair keyValuePair)
{
return this.put(keyValuePair.getOne(), keyValuePair.getTwo());
}
/**
* Puts all of the key/value mappings from the specified map into this map. If this
* map already has a value associated with one of the keys in the map, it will be
* replaced with the value in {@code map}.
* @param map the map to copy into this map
* @since 5.0.
*/
void putAll(IntObjectMap map);
/**
* Removes the mapping associated with the key, if one exists, from the map.
* @param key the key to remove
* @see #remove(int)
*/
V removeKey(int key);
/**
* Removes the mapping associated with the key, if one exists, from the map.
* @param key the key to remove
* @see #removeKey(int)
*/
V remove(int key);
/**
* Retrieves the value associated with the key if one exists; if it does not,
* associates a value with the key.
* @param key the key
* @param value the value to associate with {@code key} if no such mapping exists
* @return the value associated with key, if one exists, or {@code value} if not
*/
V getIfAbsentPut(int key, V value);
/**
* Retrieves the value associated with the key if one exists; if it does not,
* invokes the supplier and associates the result with the key.
* @param key the key
* @param function the supplier that provides the value if no mapping exists for {@code key}
* @return the value associated with the key, if one exists, or the result of
* invoking {@code function} if not
*/
V getIfAbsentPut(int key, Function0 function);
/**
* Retrieves the value associated with the key if one exists; if it does not,
* associates the result of invoking the value function with the key.
* @param key the key
* @param function the function that provides the value if no mapping exists.
* The {@code key} will be passed as the argument to the function.
* @return the value associated with the key, if one exists, or the result of
* invoking {@code function} with {@code key} if not
*/
V getIfAbsentPutWithKey(int key, IntToObjectFunction function);
/**
* Retrieves the value associated with the key if one exists; if it does not,
* invokes the value function with the parameter and associates the result with the key.
* @param key the key
* @param function the function that provides the value if no mapping exists.
* The specified {@code parameter} will be passed as the argument to the function.
* @param parameter the parameter to provide to {@code function} if no value
* exists for {@code key}
* @param the type of the value function's {@code parameter}
* @return the value associated with the key, if one exists, or the result of
* invoking {@code function} with {@code parameter} if not
*/
V getIfAbsentPutWith(int key, Function function, P parameter);
/**
* Look up the value associated with {@code key}, apply the {@code function} to it, and replace the value. If there
* is no value associated with {@code key}, start it off with a value supplied by {@code factory}.
*/
V updateValue(int key, Function0 factory, Function function);
/**
* Updates or sets the value associated with the key by applying the function to the
* existing value, if one exists, or the initial value supplied by the factory if one does not.
* @param key the key
* @param factory the supplier providing the initial value to the function if no
* mapping exists for the key
* @param function the function that returns the updated value based on the current
* value or the initial value, if no value exists. The specified {@code parameter}
* will also be passed as the second argument to the function.
* @param parameter the parameter to provide to {@code function} if no value
* exists for {@code key}
* @param
the type of the value function's {@code parameter}
* @return the new value associated with the key, either as a result of applying
* {@code function} to the value already associated with the key or as a result of
* applying it to the value returned by {@code factory} and associating the result
* with {@code key}
*/
V updateValueWith(int key, Function0 factory, Function2 function, P parameter);
@Override
MutableObjectIntMap flipUniqueValues();
@Override
MutableIntObjectMap tap(Procedure procedure);
@Override
MutableIntObjectMap select(IntObjectPredicate predicate);
@Override
MutableIntObjectMap reject(IntObjectPredicate predicate);
/**
* Associates a value with the specified key. If a value is already associated
* with the key in this map, it will be replaced with {@code value}.
* @param key the key
* @param value the value to associate with {@code value}
* @return this map
* @see #put(int, V)
*/
MutableIntObjectMap withKeyValue(int key, V value);
/**
* Removes the mapping associated with the key, if one exists, from this map.
* @param key the key to remove
* @return this map
* @see #remove(int)
*/
MutableIntObjectMap withoutKey(int key);
/**
* Removes the mappings associated with all the keys, if they exist, from this map.
* @param keys the keys to remove
* @return this map
* @see #remove(int)
*/
MutableIntObjectMap withoutAllKeys(IntIterable keys);
/**
* Puts all of the key/value mappings from the specified pairs into this map. If this
* map already has a value associated with one of the keys in the pairs, it will be
* replaced with the value in the pair.
* @param iterable the pairs to put into this map
* @return this map
* @see #putPair(IntObjectPair)
*/
default MutableIntObjectMap withAllKeyValues(Iterable> keyValuePairs)
{
for (IntObjectPair keyValuePair : keyValuePairs)
{
this.putPair(keyValuePair);
}
return this;
}
/**
* Returns an unmodifiable view of this map, delegating all read-only operations to this
* map and throwing an {@link UnsupportedOperationException} for all mutating operations.
* This avoids the overhead of copying the map when calling {@link #toImmutable()} while
* still providing immutability.
* @return an unmodifiable view of this map
*/
MutableIntObjectMap asUnmodifiable();
/**
* Returns a synchronized view of this map, delegating all operations to this map but
* ensuring only one caller has access to the map at a time.
* @return a synchronized view of this map
*/
MutableIntObjectMap asSynchronized();
/**
* Remove an entry from the map if the {@code predicate} evaluates to true.
*
* @param predicate should return true if the key/value pair should be removed.
* @return true if any entry is removed.
* @since 12.0
*/
boolean removeIf(IntObjectPredicate predicate);
}