net.openhft.koloboke.collect.map.ByteCharMapFactory Maven / Gradle / Ivy
Show all versions of koloboke-api-jdk8 Show documentation
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.koloboke.collect.map;
import net.openhft.koloboke.collect.*;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import java.util.Map;
/**
* An immutable factory of {@code ByteCharMap}s.
*
*
*
* @param the concrete factory type which extends this interface
* @see ByteCharMap
*/
public interface ByteCharMapFactory>
extends ContainerFactory {
/**
* Returns the value to which {@linkplain ByteCharMap#defaultValue() default value} of the maps
* constructed by this factory is set. Default value is {@code
* (char) 0}.
*
* @return the default value of the maps constructed by this factory
*/
char getDefaultValue();
/**
* Returns a copy of this factory, with exception that it constructs maps with
* {@linkplain ByteCharMap#defaultValue() default value} set to the given {@code char} value.
*
* @param defaultValue the new default {@code char} value
* @return a copy of this factory, which constructs maps with the given {@code defaultValue}
*/
@Nonnull
F withDefaultValue(char defaultValue);
/**
* Constructs a new empty mutable map of the {@linkplain #getDefaultExpectedSize()
* default expected size}.
*
* @return a new empty mutable map
*/
@Nonnull
ByteCharMap newMutableMap();
/**
* Constructs a new empty mutable map of the given expected size.
*
* @param expectedSize the expected size of the returned map
* @return a new empty mutable map of the given expected size
*/
@Nonnull
ByteCharMap newMutableMap(int expectedSize);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param expectedSize the expected size of the returned map
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2, int expectedSize);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param expectedSize the expected size of the returned map
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3, int expectedSize);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param expectedSize the expected size of the returned map
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4, int expectedSize);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
* @param expectedSize the expected size of the returned map
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5, int expectedSize);
/**
* Constructs a new mutable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
* @param expectedSize the expected size of the returned map
* @return a new mutable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull
Consumer entriesSupplier
, int expectedSize);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newMutableMap(
@Nonnull byte[] keys, @Nonnull char[] values, int expectedSize);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newMutableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values, int expectedSize);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
* @param expectedSize the expected size of the returned map
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Iterable keys,
@Nonnull Iterable values, int expectedSize);
/**
* Constructs a new mutable map with the same mappings as the specified {@code map}.
*
*
*
* @param map the map whose mappings are to be placed in the returned map
*
* @return a new mutable map with the same mappings as the specified {@code map}
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
*
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
*
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
*
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4);
/**
* Constructs a new mutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
*
* @return a new mutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5);
/**
* Constructs a new mutable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
*
* @return a new mutable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull
Consumer entriesSupplier
);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newMutableMap(
@Nonnull byte[] keys, @Nonnull char[] values);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newMutableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values);
/**
* Constructs a new mutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
*
* @return a new mutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newMutableMap(@Nonnull Iterable keys,
@Nonnull Iterable values);
/**
* Constructs a new mutable map of the single specified mapping.
*
* @param k1 the key of the sole mapping
* @param v1 the value of the sole mapping
* @return a new mutable map of the single specified mapping
*/
@Nonnull
ByteCharMap newMutableMapOf(byte k1, char v1);
/**
* Constructs a new mutable map of the two specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @return a new mutable map of the two specified mappings
*/
@Nonnull
ByteCharMap newMutableMapOf(byte k1, char v1,
byte k2, char v2);
/**
* Constructs a new mutable map of the three specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @return a new mutable map of the three specified mappings
*/
@Nonnull
ByteCharMap newMutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3);
/**
* Constructs a new mutable map of the four specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @return a new mutable map of the four specified mappings
*/
@Nonnull
ByteCharMap newMutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4);
/**
* Constructs a new mutable map of the five specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @param k5 the key of the fifth mapping
* @param v5 the value of the fifth mapping
* @return a new mutable map of the five specified mappings
*/
@Nonnull
ByteCharMap newMutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4, byte k5, char v5);
/**
* Constructs a new empty updatable map of the {@linkplain #getDefaultExpectedSize()
* default expected size}.
*
* @return a new empty updatable map
*/
@Nonnull
ByteCharMap newUpdatableMap();
/**
* Constructs a new empty updatable map of the given expected size.
*
* @param expectedSize the expected size of the returned map
* @return a new empty updatable map of the given expected size
*/
@Nonnull
ByteCharMap newUpdatableMap(int expectedSize);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param expectedSize the expected size of the returned map
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2, int expectedSize);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param expectedSize the expected size of the returned map
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3, int expectedSize);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param expectedSize the expected size of the returned map
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4, int expectedSize);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
* @param expectedSize the expected size of the returned map
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5, int expectedSize);
/**
* Constructs a new updatable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
* @param expectedSize the expected size of the returned map
* @return a new updatable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull
Consumer entriesSupplier
, int expectedSize);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newUpdatableMap(
@Nonnull byte[] keys, @Nonnull char[] values, int expectedSize);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newUpdatableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values, int expectedSize);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
* @param expectedSize the expected size of the returned map
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Iterable keys,
@Nonnull Iterable values, int expectedSize);
/**
* Constructs a new updatable map with the same mappings as the specified {@code map}.
*
*
*
* @param map the map whose mappings are to be placed in the returned map
*
* @return a new updatable map with the same mappings as the specified {@code map}
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
*
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
*
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
*
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4);
/**
* Constructs a new updatable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
*
* @return a new updatable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5);
/**
* Constructs a new updatable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
*
* @return a new updatable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull
Consumer entriesSupplier
);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newUpdatableMap(
@Nonnull byte[] keys, @Nonnull char[] values);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newUpdatableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values);
/**
* Constructs a new updatable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
*
* @return a new updatable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newUpdatableMap(@Nonnull Iterable keys,
@Nonnull Iterable values);
/**
* Constructs a new updatable map of the single specified mapping.
*
* @param k1 the key of the sole mapping
* @param v1 the value of the sole mapping
* @return a new updatable map of the single specified mapping
*/
@Nonnull
ByteCharMap newUpdatableMapOf(byte k1, char v1);
/**
* Constructs a new updatable map of the two specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @return a new updatable map of the two specified mappings
*/
@Nonnull
ByteCharMap newUpdatableMapOf(byte k1, char v1,
byte k2, char v2);
/**
* Constructs a new updatable map of the three specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @return a new updatable map of the three specified mappings
*/
@Nonnull
ByteCharMap newUpdatableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3);
/**
* Constructs a new updatable map of the four specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @return a new updatable map of the four specified mappings
*/
@Nonnull
ByteCharMap newUpdatableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4);
/**
* Constructs a new updatable map of the five specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @param k5 the key of the fifth mapping
* @param v5 the value of the fifth mapping
* @return a new updatable map of the five specified mappings
*/
@Nonnull
ByteCharMap newUpdatableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4, byte k5, char v5);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param expectedSize the expected size of the returned map
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2, int expectedSize);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param expectedSize the expected size of the returned map
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3, int expectedSize);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param expectedSize the expected size of the returned map
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4, int expectedSize);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
* @param expectedSize the expected size of the returned map
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5, int expectedSize);
/**
* Constructs a new immutable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
* @param expectedSize the expected size of the returned map
* @return a new immutable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull
Consumer entriesSupplier
, int expectedSize);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newImmutableMap(
@Nonnull byte[] keys, @Nonnull char[] values, int expectedSize);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
* @param expectedSize the expected size of the returned map
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newImmutableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values, int expectedSize);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
* @param expectedSize the expected size of the returned map
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Iterable keys,
@Nonnull Iterable values, int expectedSize);
/**
* Constructs a new immutable map with the same mappings as the specified {@code map}.
*
*
*
* @param map the map whose mappings are to be placed in the returned map
*
* @return a new immutable map with the same mappings as the specified {@code map}
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the {@code map2} have priority over mappings from the {@code map1} with
* the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
*
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
*
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
*
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4);
/**
* Constructs a new immutable map which merge the mappings of the specified maps. On conflict,
* mappings from the maps passed later in the argument list have priority over mappings
* from the maps passed earlier with the same keys.
*
* @param map1 the first map to merge
* @param map2 the second map to merge
* @param map3 the third map to merge
* @param map4 the fourth map to merge
* @param map5 the fifth map to merge
*
* @return a new immutable map which merge the mappings of the specified maps
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Map map1,
@Nonnull Map map2,
@Nonnull Map map3,
@Nonnull Map map4,
@Nonnull Map map5);
/**
* Constructs a new immutable map filled with mappings consumed by the callback within the given
* closure. Mappings supplied later within the closure have priority over the mappings
* passed earlier with the same keys.
*
* Example: TODO
*
* @param entriesSupplier the function which supply mappings for the returned map via
* the callback passed in
*
* @return a new immutable map with mappings consumed by the callback within the given closure
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull
Consumer entriesSupplier
);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
*/
@Nonnull
ByteCharMap newImmutableMap(
@Nonnull byte[] keys, @Nonnull char[] values);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} arrays at the same index. If {@code keys} array have
* duplicate elements, value corresponding the key with the highest index is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} array at the same index
*
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} arrays have different
* length
* @throws NullPointerException if {@code keys}
* or {@code
* values} contain {@code null} elements
*/
@Nonnull
ByteCharMap newImmutableMap(
@Nonnull Byte[] keys, @Nonnull Character[] values);
/**
* Constructs a new immutable map with the given mappings, i. e. pairs of elements from
* the {@code keys} and {@code values} iterables at the same iteration position. If {@code keys}
* have duplicate elements, value corresponding the key appeared last in the iteration is left
* in the returned map.
*
* @param keys the keys of the returned map
* @param values the values of the returned map, each value is associated with the element
* of the {@code keys} iterable at the same iteration position
*
* @return a new immutable map with the given mappings
* @throws IllegalArgumentException if {@code keys} and {@code values} have different size
*/
@Nonnull
ByteCharMap newImmutableMap(@Nonnull Iterable keys,
@Nonnull Iterable values);
/**
* Constructs a new immutable map of the single specified mapping.
*
* @param k1 the key of the sole mapping
* @param v1 the value of the sole mapping
* @return a new immutable map of the single specified mapping
*/
@Nonnull
ByteCharMap newImmutableMapOf(byte k1, char v1);
/**
* Constructs a new immutable map of the two specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @return a new immutable map of the two specified mappings
*/
@Nonnull
ByteCharMap newImmutableMapOf(byte k1, char v1,
byte k2, char v2);
/**
* Constructs a new immutable map of the three specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @return a new immutable map of the three specified mappings
*/
@Nonnull
ByteCharMap newImmutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3);
/**
* Constructs a new immutable map of the four specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @return a new immutable map of the four specified mappings
*/
@Nonnull
ByteCharMap newImmutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4);
/**
* Constructs a new immutable map of the five specified mappings.
*
* @param k1 the key of the first mapping
* @param v1 the value of the first mapping
* @param k2 the key of the second mapping
* @param v2 the value of the second mapping
* @param k3 the key of the third mapping
* @param v3 the value of the third mapping
* @param k4 the key of the fourth mapping
* @param v4 the value of the fourth mapping
* @param k5 the key of the fifth mapping
* @param v5 the value of the fifth mapping
* @return a new immutable map of the five specified mappings
*/
@Nonnull
ByteCharMap newImmutableMapOf(byte k1, char v1,
byte k2, char v2, byte k3, char v3,
byte k4, char v4, byte k5, char v5);
}