io.qt.core.QMultiHash Maven / Gradle / Ivy
/****************************************************************************
**
** Copyright (C) 2009-2024 Dr. Peter Droste, Omix Visualization GmbH & Co. KG. All rights reserved.
**
** This file is part of Qt Jambi.
**
** $BEGIN_LICENSE$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
** $END_LICENSE$
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
package io.qt.core;
import static io.qt.core.QMap.findMapMetaType;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
import io.qt.NativeAccess;
import io.qt.NonNull;
import io.qt.Nullable;
import io.qt.QNoImplementationException;
import io.qt.QNoNativeResourcesException;
import io.qt.QtUninvokable;
import io.qt.StrictNonNull;
/**
* Java wrapper for Qt class QMultiHash
*/
public class QMultiHash extends AbstractMultiAssociativeContainer implements Map>, Cloneable
{
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Constructor for internal use only.
* @param p expected to be null.
* @hidden
*/
@NativeAccess
protected QMultiHash(QPrivateConstructor p) {
super(p);
}
/**
* Creating a container with given key and value type.
*
* @param keyType the type K
* @param valueMetaType the type V
*/
public QMultiHash(Class keyType, QMetaType.Type valueMetaType) {
this(keyType, new QMetaType(valueMetaType));
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueType the type V
*/
public QMultiHash(QMetaType.Type keyMetaType, Class valueType) {
this(new QMetaType(keyMetaType), valueType);
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueMetaType the type V
*/
public QMultiHash(QMetaType.Type keyMetaType, QMetaType valueMetaType) {
this(new QMetaType(keyMetaType), valueMetaType);
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueMetaType the type V
*/
public QMultiHash(QMetaType keyMetaType, QMetaType.Type valueMetaType) {
this(keyMetaType, new QMetaType(valueMetaType));
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueMetaType the type V
*/
public QMultiHash(QMetaType.Type keyMetaType, QMetaType.Type valueMetaType) {
this(new QMetaType(keyMetaType), new QMetaType(valueMetaType));
}
/**
* Creating a container with given key and value type.
*
* @param keyType the type K
* @param valueType the type V
*/
public QMultiHash(Class keyType, Class valueType) {
super(null);
QMetaType keyMetaType = QMetaType.fromType(keyType);
QMetaType valueMetaType = QMetaType.fromType(valueType);
initialize(keyType, QtJambi_LibraryUtilities.internal.nativeId(keyMetaType), valueType, QtJambi_LibraryUtilities.internal.nativeId(valueMetaType), null);
}
/**
* Creating a container with given content.
* See QMultiHash::QMultiHash(const QHash<Key, T> &)
* @param other map
*/
public QMultiHash(Map> other) {
super(null);
QPair metaTypes = findMapMetaType(Objects.requireNonNull(other, "Argument 'other': null not expected."));
initialize(metaTypes.first.javaType(), QtJambi_LibraryUtilities.internal.nativeId(metaTypes.first), metaTypes.second.javaType(), QtJambi_LibraryUtilities.internal.nativeId(metaTypes.second), other);
}
/**
* Creating a container with given key and value type.
*
* @param keyType the type K
* @param valueMetaType the type V
*/
public QMultiHash(Class keyType, QMetaType valueMetaType) {
super(null);
QMetaType keyMetaType = QMetaType.fromType(keyType);
initialize(keyMetaType.javaType(), QtJambi_LibraryUtilities.internal.nativeId(keyMetaType), valueMetaType.javaType(), QtJambi_LibraryUtilities.internal.nativeId(valueMetaType), null);
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueType the type V
*/
public QMultiHash(QMetaType keyMetaType, Class valueType) {
super(null);
QMetaType valueMetaType = QMetaType.fromType(valueType);
initialize(keyMetaType.javaType(), QtJambi_LibraryUtilities.internal.nativeId(keyMetaType), valueType, QtJambi_LibraryUtilities.internal.nativeId(valueMetaType), null);
}
/**
* Creating a container with given key and value type.
*
* @param keyMetaType the type K
* @param valueMetaType the type V
*/
public QMultiHash(QMetaType keyMetaType, QMetaType valueMetaType) {
super(null);
initialize(keyMetaType.javaType(), QtJambi_LibraryUtilities.internal.nativeId(keyMetaType), valueMetaType.javaType(), QtJambi_LibraryUtilities.internal.nativeId(valueMetaType), null);
}
@QtUninvokable
private native void initialize(Class keyType, long keyMetaType, Class valueType, long valueMetaType, Map> other);
/**
* Creates and returns a copy of this object.
*/
@Override
public QMultiHash clone(){
return new QMultiHash<>(this);
}
/**
* See QMultiHash::capacity()const
*/
@QtUninvokable
public final int capacity() {
return capacity(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native int capacity(long __this__nativeId);
/**
*
*/
@QtUninvokable
public final void clear() {
clear(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native void clear(long __this__nativeId);
/**
* See QMultiHash::contains(Key)const
*/
@QtUninvokable
public final boolean contains(Key key) {
try{
return contains(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QSet.handleException(e, keyMetaType(), key);
}
}
@QtUninvokable
private native boolean contains(long __this__nativeId, Object key);
/**
*
*/
@QtUninvokable
public final int count() {
return size();
}
/**
* See QMultiHash::count(Key)const
*/
@QtUninvokable
public final int count(Key key) {
try{
return count(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QSet.handleException(e, keyMetaType(), key);
}
}
@QtUninvokable
private native int count(long __this__nativeId, Key key);
/**
* Provides a mutable C++ iterator to the containers begin.
*
* @return begin
*/
@QtUninvokable
protected final io.qt.core.QAssociativeIterator begin() {
return begin(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native io.qt.core.QAssociativeIterator begin(long __this__nativeId);
/**
* Provides a mutable C++ iterator to the containers end.
*
* @return end
*/
@QtUninvokable
protected final io.qt.core.QAssociativeIterator end() {
return end(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native io.qt.core.QAssociativeIterator end(long __this__nativeId);
/**
* Provides a constant C++ iterator to the containers begin.
* See QMultiHash::constBegin()const
* @return begin
*/
@QtUninvokable
protected final io.qt.core.QAssociativeConstIterator constBegin() {
return constBegin(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native io.qt.core.QAssociativeConstIterator constBegin(long __this__nativeId);
/**
* Provides a constant C++ iterator to the containers end.
* See QMultiHash::constEnd()const
* @return end
*/
@QtUninvokable
protected final io.qt.core.QAssociativeConstIterator constEnd() {
return constEnd(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native io.qt.core.QAssociativeConstIterator constEnd(long __this__nativeId);
/**
* See QMultiHash::find(Key)const
* @return iterator
*/
@QtUninvokable
public final io.qt.core.QAssociativeConstIterator find(Key key) {
return find(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}
@QtUninvokable
private native io.qt.core.QAssociativeConstIterator find(long __this__nativeId, Key key);
/**
*
*/
@QtUninvokable
public final void insert(Key key, T value) {
try{
insert(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
@QtUninvokable
private native void insert(long __this__nativeId, Key key, T value);
/**
* See QMultiHash::isEmpty()const
*/
@QtUninvokable
public final boolean isEmpty() {
return size()==0;
}
/**
*
*/
@QtUninvokable
public final Key key(T value) {
return key(value, null);
}
/**
* See QMultiHash::key(T,Key)const
*/
@QtUninvokable
public final Key key(T value, Key defaultKey) {
try{
return key(QtJambi_LibraryUtilities.internal.nativeId(this), value, defaultKey);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), defaultKey, value);
}
}
@QtUninvokable
private native Key key(long __this__nativeId, T value, Key defaultKey);
/**
* Returns a {@link List} of the keys contained in this associative container.
*
* @return list of keys
*/
@QtUninvokable
public final QList keys() {
return keys(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native QList keys(long __this__nativeId);
/**
*
*/
@QtUninvokable
public final QList keys(T value) {
try{
return keysForValue(QtJambi_LibraryUtilities.internal.nativeId(this), value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QSet.handleException(e, valueMetaType(), value);
}
}
@QtUninvokable
private native QList keysForValue(long __this__nativeId, Object value);
/**
* See QMultiHash::removeIf(Predicate)
*/
@QtUninvokable
public final int removeIf(Predicate predicate) {
List keys = new ArrayList<>();
final long nativeId = QtJambi_LibraryUtilities.internal.nativeId(this);
for(Key key : keys(nativeId)) {
if(predicate.test(key))
keys.add(key);
}
int count = 0;
for (Key key : keys) {
count += remove(nativeId, key);
}
return count;
}
/**
* See QMultiHash::removeIf(Predicate)
*/
@QtUninvokable
public final int removeIf(BiPredicate predicate) {
List> pairs = new ArrayList<>();
final long nativeId = QtJambi_LibraryUtilities.internal.nativeId(this);
for(QPair pair : constBegin(nativeId)) {
if(predicate.test(pair.first, pair.second))
pairs.add(pair);
}
int count = 0;
for (QPair pair : pairs) {
count += remove(nativeId, pair.first, pair.second);
}
return count;
}
/**
*
*/
@QtUninvokable
public final int removeAll(Object key) {
try{
return remove(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(IllegalArgumentException e) {
return 0;
}catch(RuntimeException e) {
RuntimeException e1 = QSet.handleException(e, keyMetaType(), key);
if(e1==e)
throw e;
return 0;
}
}
@QtUninvokable
private native int remove(long __this__nativeId, Object key);
/**
*
*/
@QtUninvokable
public final void reserve(int size) {
reserve(QtJambi_LibraryUtilities.internal.nativeId(this), size);
}
@QtUninvokable
private native void reserve(long __this__nativeId, int size);
/**
*
*/
@QtUninvokable
public final int size() {
return size(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native int size(long __this__nativeId);
/**
*
*/
@QtUninvokable
public final void squeeze() {
reserve(0);
}
/**
*
*/
@QtUninvokable
public final T take(Key key) {
try{
return take(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QSet.handleException(e, keyMetaType(), key);
}
}
@QtUninvokable
private native T take(long __this__nativeId, Key key);
/**
* See QMultiHash::uniqueKeys()const
*/
@QtUninvokable
public final QList uniqueKeys() {
return uniqueKeys(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private static native QList uniqueKeys(long __this__nativeId);
/**
* See QMultiHash::unite(const QHash<Key, T> &)
*/
@QtUninvokable
public final void unite(QHash other) {
unite(QtJambi_LibraryUtilities.internal.nativeId(this), other);
}
/**
* See QMultiHash::unite(const QMultiHash<Key, T> &)
*/
@QtUninvokable
public final void unite(java.util.Map> other) {
unite(QtJambi_LibraryUtilities.internal.nativeId(this), other);
}
@QtUninvokable
private static native void unite(long __this__nativeId, Object other);
/**
*
*/
@QtUninvokable
public final T value(Key key) {
return value(key, null);
}
/**
*
*/
@QtUninvokable
public final T value(Key key, T defaultValue) {
try{
return value(QtJambi_LibraryUtilities.internal.nativeId(this), key, defaultValue);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, defaultValue);
}
}
@QtUninvokable
private native T value(long __this__nativeId, Object key, Object defaultValue);
/**
* Returns a {@link List} of the values contained in this multihash.
* @see Map#values()
*/
@QtUninvokable
public final java.util.List> values() {
long id = QtJambi_LibraryUtilities.internal.nativeId(this);
java.util.List> result = new java.util.ArrayList<>();
for(Object key : uniqueKeys(id)) {
result.add(valuesKey(id, key));
}
return result;
}
/**
*
*/
@QtUninvokable
public final QList listOfValues() {
return values(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@QtUninvokable
private native QList values(long __this__nativeId);
/**
* See QMultiHash::values(Key)const
*/
@QtUninvokable
public final QList values(Key key) {
try{
return valuesKey(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QSet.handleException(e, keyMetaType(), key);
}
}
@QtUninvokable
private static native QList valuesKey(long __this__nativeId, Key key);
/**
* See QMultiHash::count(Key,T)const
*/
@QtUninvokable
public final int count(Key key, T value) {
try{
return count(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
private static native int count(long __this__nativeId, Key key, T value);
/**
* See QMultiHash::find(Key,T)const
*/
@QtUninvokable
public final io.qt.core.QAssociativeConstIterator find(Key key, T value) {
try{
return find(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
private static native io.qt.core.QAssociativeConstIterator find(long __this__nativeId, Key key, T value);
/**
*
*/
@QtUninvokable
public final int removeAll(Key key, T value) {
try{
return remove(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
private static native int remove(long __this__nativeId, Key key, T value);
/**
* See QMultiHash::replace(Key,T)
*/
@QtUninvokable
public final void replaceOne(Key key, T value) {
try{
replaceOne(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
private static native void replaceOne(long __this__nativeId, Key key, T value);
/**
* See QMultiHash::contains(Key,T)const
*/
@QtUninvokable
public final boolean contains(Key key, T value) {
try{
return contains(QtJambi_LibraryUtilities.internal.nativeId(this), key, value);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(RuntimeException e) {
throw QMap.handleException(e, keyMetaType(), valueMetaType(), key, value);
}
}
private static native boolean contains(long __this__nativeId, Key key, T value);
/**
* See operator==(QMultiHash<Key,T>,QMultiHash<Key,T>)
*/
@SuppressWarnings("unchecked")
@Override
@QtUninvokable
public boolean equals(Object other) {
if (other instanceof java.util.Map && QMap.checkContainerType(this.keyMetaType(), this.valueMetaType(), (java.util.Map) other)) {
return operator_equal(QtJambi_LibraryUtilities.internal.nativeId(this), (java.util.Map) other);
}
return false;
}
@QtUninvokable
private native boolean operator_equal(long __this__nativeId, java.util.Map other);
/**
* Returns the objects's hash code computed by qHash(QMultiHash<Key,T>).
*/
@Override
@QtUninvokable
public int hashCode() {
try {
return hashCode(QtJambi_LibraryUtilities.internal.nativeId(this));
} catch (QNoNativeResourcesException e) {
return 0;
}
}
@QtUninvokable
private static native int hashCode(long __this__nativeId);
/**
* Returns the string representation of the object given by QVariant(this).toString().
*/
@Override
@QtUninvokable
public String toString() {
try {
return toString(QtJambi_LibraryUtilities.internal.nativeId(this));
} catch (QNoImplementationException e) {
return super.toString();
} catch (QNoNativeResourcesException e) {
return "null";
}
}
@QtUninvokable
private static native String toString(long __this__nativeId);
/**
* Returns {@code true} if this map contains a mapping for the specified key.
* @see Map#containsKey(Object)
* @see #contains(Object)
*/
@Override
@QtUninvokable
public final boolean containsKey(Object key){
try{
return contains(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(IllegalArgumentException e) {
return false;
}catch(RuntimeException e) {
RuntimeException e1 = QSet.handleException(e, keyMetaType(), key);
if(e1==e)
throw e;
return false;
}
}
/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
* @see Map#get(Object)
* @see #value(Object)
*/
@Override
@QtUninvokable
public final List get(Object key){
try{
return valuesKey(QtJambi_LibraryUtilities.internal.nativeId(this), key);
}catch(QNoNativeResourcesException e) {
throw e;
}catch(IllegalArgumentException e) {
return null;
}catch(RuntimeException e) {
RuntimeException e1 = QSet.handleException(e, keyMetaType(), key);
if(e1==e)
throw e;
return null;
}
}
/**
* Associates the specified value with the specified key in this map.
* @see Map#put(Object, Object)
* @see #insert(Object, Object)
*/
@Override
@QtUninvokable
public final java.util.List put(Key key, java.util.List values){
java.util.List old = values(key);
for(T value : values)
insert(key, value);
return old;
}
/**
* Removes the mapping for a key from this map if it is present.
* @see Map#remove(Object)
* @see #take(Object)
*/
@Override
@QtUninvokable
public final java.util.List remove(Object key){
try{
@SuppressWarnings("unchecked")
java.util.List result = valuesKey(QtJambi_LibraryUtilities.internal.nativeId(this), (Key)key);
removeAll(key);
return result;
}catch(QNoNativeResourcesException e) {
throw e;
}catch(IllegalArgumentException e) {
return Collections.emptyList();
}catch(RuntimeException e) {
RuntimeException e1 = QSet.handleException(e, keyMetaType(), key);
if(e1==e)
throw e;
return Collections.emptyList();
}
}
/**
* Returns {@code true} if this map maps one or more keys to the
* specified value.
* @see Map#containsValue(Object)
* @see #key(Object, Object)
*/
@Override
@QtUninvokable
public final boolean containsValue(Object value){
try {
return !keysForValue(QtJambi_LibraryUtilities.internal.nativeId(this), value).isEmpty();
}catch(QNoNativeResourcesException e) {
throw e;
}catch(IllegalArgumentException e) {
return false;
}catch(RuntimeException e) {
RuntimeException e1 = QSet.handleException(e, valueMetaType(), value);
if(e1==e)
throw e;
return false;
}
}
/**
* See operator<<(QDataStream&,QMultiHash<Key,T>)
*/
@io.qt.QtUninvokable
public void writeTo(io.qt.core.QDataStream stream){
writeTo(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.nativeId(stream));
}
@io.qt.QtUninvokable
private native void writeTo(long __this__nativeId, long stream);
/**
* See operator>>(QDataStream&,QMultiHash<Key,T>&)
*/
@io.qt.QtUninvokable
public void readFrom(io.qt.core.QDataStream stream){
readFrom(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.nativeId(stream));
}
@io.qt.QtUninvokable
private native void readFrom(long __this__nativeId, long stream);
@io.qt.QtUninvokable
final QMetaType keyMetaType() {
return keyMetaType(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@io.qt.QtUninvokable
private native QMetaType keyMetaType(long __this_nativeId);
@io.qt.QtUninvokable
final QMetaType valueMetaType() {
return valueMetaType(QtJambi_LibraryUtilities.internal.nativeId(this));
}
@io.qt.QtUninvokable
private native QMetaType valueMetaType(long __this_nativeId);
/**
* Returns a QMultiHash containing a single mapping.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the mapping's key
* @param t1 the mapping's value
* @return a {@code QMultiHash} containing the specified mapping
* @throws NullPointerException if the key or the value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1),
QList.findElementMetaType(t1));
result.insert(k1, t1);
return result;
}
/**
* Returns a QMultiHash containing two mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2),
QList.findElementMetaType(t1, t2));
result.insert(k1, t1);
result.insert(k2, t2);
return result;
}
/**
* Returns a QMultiHash containing three mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3),
QList.findElementMetaType(t1, t2, t3));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
return result;
}
/**
* Returns a QMultiHash containing four mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4),
QList.findElementMetaType(t1, t2, t3, t4));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
return result;
}
/**
* Returns a QMultiHash containing five mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5),
QList.findElementMetaType(t1, t2, t3, t4, t5));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
return result;
}
/**
* Returns a QMultiHash containing six mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5, k6),
QList.findElementMetaType(t1, t2, t3, t4, t5, t6));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
return result;
}
/**
* Returns a QMultiHash containing seven mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5, k6, k7),
QList.findElementMetaType(t1, t2, t3, t4, t5, t6, t7));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
return result;
}
/**
* Returns a QMultiHash containing eight mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5, k6, k7, k8),
QList.findElementMetaType(t1, t2, t3, t4, t5, t6, t7, t8));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
return result;
}
/**
* Returns a QMultiHash containing nine mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5, k6, k7, k8, k9),
QList.findElementMetaType(t1, t2, t3, t4, t5, t6, t7, t8, t9));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
result.insert(k9, t9);
return result;
}
/**
* Returns a QMultiHash containing ten mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @param k10 the tenth mapping's key
* @param t10 the tenth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any key or value is {@code null}
*/
public static @NonNull QMultiHash of(Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9, Key k10, T t10) {
QMultiHash result = new QMultiHash<>(
QList.findElementMetaType(k1, k2, k3, k4, k5, k6, k7, k8, k9, k10),
QList.findElementMetaType(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
result.insert(k9, t9);
result.insert(k10, t10);
return result;
}
/**
* Returns a QMultiHash containing keys and values extracted from the given entries.
*
* @apiNote
* It is convenient to create the map entries using the {@link Map#entry Map.entry()} method.
* For example,
*
* {@code
* import static java.util.Map.entry;
*
* QMultiHash map = QMultiHash.ofEntries(
* entry(1, "a"),
* entry(2, "b"),
* entry(3, "c"),
* ...
* entry(26, "z"));
* }
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param entries {@code java.util.Map.Entry}s containing the keys and values from which the map is populated
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any entry, key, or value is {@code null}, or if
* the {@code entries} array is {@code null}
*/
@SafeVarargs
public static @NonNull QMultiHash ofEntries(Map.@StrictNonNull Entry entry0, Map.@StrictNonNull Entry @StrictNonNull... entries) {
QPair metaTypes = findMapMetaType(entry0, entries);
QMultiHash result = new QMultiHash<>(metaTypes.first, metaTypes.second);
result.insert(entry0.getKey(), entry0.getValue());
for (Map.Entry entry : entries) {
result.insert(entry.getKey(), entry.getValue());
}
return result;
}
/**
* Returns a QMultiHash containing keys and values extracted from the given pairs.
*
* @apiNote
* It is convenient to create the pair using the {@link QPair#pair(Object, Object)} method.
* For example,
*
* {@code
* import static java.util.QPair.pair;
*
* QMultiHash map = QMultiHash.ofPairs(
* pair(1, "a"),
* pair(2, "b"),
* pair(3, "c"),
* ...
* pair(26, "z"));
* }
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param pairs {@code QPair}s containing the keys and values from which the map is populated
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any entry, key, or value is {@code null}, or if
* the {@code entries} array is {@code null}
*/
@SafeVarargs
public static @NonNull QMultiHash ofPairs(@StrictNonNull QPair pair0, @StrictNonNull QPair @StrictNonNull... pairs) {
QPair metaTypes = findMapMetaType(pair0, pairs);
QMultiHash result = new QMultiHash<>(metaTypes.first, metaTypes.second);
result.insert(pair0.first, pair0.second);
for (QPair entry : pairs) {
result.insert(entry.first, entry.second);
}
return result;
}
/**
* Returns a QMultiHash containing a single mapping.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the mapping's key
* @param t1 the mapping's value
* @return a {@code QMultiHash} containing the specified mapping
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1) {
return ofTyped(
QList.findElementMetaType(keyType, k1),
QList.findElementMetaType(valueType, t1),
k1, t1);
}
/**
* Returns a QMultiHash containing two mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2),
QList.findElementMetaType(valueType, t1, t2), k1, t1, k2, t2);
}
/**
* Returns a QMultiHash containing three mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3),
QList.findElementMetaType(valueType, t1, t2, t3),
k1, t1,
k2, t2,
k3, t3);
}
/**
* Returns a QMultiHash containing four mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4),
QList.findElementMetaType(valueType, t1, t2, t3, t4),
k1, t1,
k2, t2,
k3, t3,
k4, t4);
}
/**
* Returns a QMultiHash containing five mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5),
k1, t1,
k2, t2,
k3, t3,
k4, t4,
k5, t5);
}
/**
* Returns a QMultiHash containing six mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5, Key k6, T t6) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5, k6),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5, t6),
k1, t1,
k2, t2,
k3, t3,
k4, t4,
k5, t5,
k6, t6);
}
/**
* Returns a QMultiHash containing seven mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5, k6, k7),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5, t6, t7),
k1, t1,
k2, t2,
k3, t3,
k4, t4,
k5, t5,
k6, t6,
k7, t7);
}
/**
* Returns a QMultiHash containing eight mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5, k6, k7, k8),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5, t6, t7, t8),
k1, t1,
k2, t2,
k3, t3,
k4, t4,
k5, t5,
k6, t6,
k7, t7,
k8, t8);
}
/**
* Returns a QMultiHash containing nine mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5, k6, k7, k8, k9),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5, t6, t7, t8, t9),
k1, t1, k2, t2,
k3, t3,
k4, t4,
k5, t5,
k6, t6,
k7, t7,
k8, t8,
k9, t9);
}
/**
* Returns a QMultiHash containing ten mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @param k10 the tenth mapping's key
* @param t10 the tenth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@Nullable Class keyType, @Nullable Class valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9, Key k10, T t10) {
return ofTyped(
QList.findElementMetaType(keyType, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10),
QList.findElementMetaType(valueType, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10),
k1, t1,
k2, t2,
k3, t3,
k4, t4,
k5, t5,
k6, t6,
k7, t7,
k8, t8,
k9, t9,
k10, t10);
}
/**
* Returns a QMultiHash containing a single mapping.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the mapping's key
* @param t1 the mapping's value
* @return a {@code QMultiHash} containing the specified mapping
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1) {
if(keyType.id()==0)
throw new IllegalArgumentException("QMetaType::UnknownType cannot be key type of QMultiHash.");
if(keyType.id()==QMetaType.Type.Void.value())
throw new IllegalArgumentException("void cannot be key type of QMultiHash.");
if(valueType.id()==0)
throw new IllegalArgumentException("QMetaType::UnknownType cannot be value type of QMultiHash.");
if(valueType.id()==QMetaType.Type.Void.value())
throw new IllegalArgumentException("void cannot be value type of QMultiHash.");
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
return result;
}
/**
* Returns a QMultiHash containing two mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
return result;
}
/**
* Returns a QMultiHash containing three mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
return result;
}
/**
* Returns a QMultiHash containing four mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
return result;
}
/**
* Returns a QMultiHash containing five mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
return result;
}
/**
* Returns a QMultiHash containing six mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5, Key k6, T t6) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
return result;
}
/**
* Returns a QMultiHash containing seven mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
return result;
}
/**
* Returns a QMultiHash containing eight mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
return result;
}
/**
* Returns a QMultiHash containing nine mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
result.insert(k9, t9);
return result;
}
/**
* Returns a QMultiHash containing ten mappings.
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param k1 the first mapping's key
* @param t1 the first mapping's value
* @param k2 the second mapping's key
* @param t2 the second mapping's value
* @param k3 the third mapping's key
* @param t3 the third mapping's value
* @param k4 the fourth mapping's key
* @param t4 the fourth mapping's value
* @param k5 the fifth mapping's key
* @param t5 the fifth mapping's value
* @param k6 the sixth mapping's key
* @param t6 the sixth mapping's value
* @param k7 the seventh mapping's key
* @param t7 the seventh mapping's value
* @param k8 the eighth mapping's key
* @param t8 the eighth mapping's value
* @param k9 the ninth mapping's key
* @param t9 the ninth mapping's value
* @param k10 the tenth mapping's key
* @param t10 the tenth mapping's value
* @return a {@code QMultiHash} containing the specified mappings
*/
public static @NonNull QMultiHash ofTyped(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Key k1, T t1, Key k2, T t2, Key k3, T t3, Key k4, T t4, Key k5, T t5,
Key k6, T t6, Key k7, T t7, Key k8, T t8, Key k9, T t9, Key k10, T t10) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
result.insert(k1, t1);
result.insert(k2, t2);
result.insert(k3, t3);
result.insert(k4, t4);
result.insert(k5, t5);
result.insert(k6, t6);
result.insert(k7, t7);
result.insert(k8, t8);
result.insert(k9, t9);
result.insert(k10, t10);
return result;
}
/**
* Returns a QMultiHash containing keys and values extracted from the given entries.
*
* @apiNote
* It is convenient to create the map entries using the {@link Map#entry Map.entry()} method.
* For example,
*
* {@code
* import static java.util.Map.entry;
*
* QMultiHash map = QMultiHash.ofTypedEntries(
* int.class,
* String.class,
* entry(1, "a"),
* entry(2, "b"),
* entry(3, "c"),
* ...
* entry(26, "z"));
* }
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param entries {@code java.util.Map.Entry}s containing the keys and values from which the map is populated
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any entry, key, or value is {@code null}, or if
* the {@code entries} array is {@code null}
*/
@SafeVarargs
public static @NonNull QMultiHash ofTypedEntries(@Nullable Class keyType, @Nullable Class valueType, Map.Entry... entries) {
QPair metaTypes = QMap.findMapMetaType(keyType, valueType, entries);
return ofTypedEntries(metaTypes.first, metaTypes.second, entries);
}
/**
* Returns a QMultiHash containing keys and values extracted from the given entries.
*
* @apiNote
* It is convenient to create the map entries using the {@link Map#entry Map.entry()} method.
* For example,
*
* {@code
* import static java.util.Map.entry;
*
* QMultiHash map = QMultiHash.ofTypedEntries(
* QMetaType.fromType(int.class),
* QMetaType.fromType(String.class),
* entry(1, "a"),
* entry(2, "b"),
* entry(3, "c"),
* ...
* entry(26, "z"));
* }
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param keyType key type
* @param valueType value type
* @param entries {@code java.util.Map.Entry}s containing the keys and values from which the map is populated
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any entry, key, or value is {@code null}, or if
* the {@code entries} array is {@code null}
*/
@SafeVarargs
public static @NonNull QMultiHash ofTypedEntries(@StrictNonNull QMetaType keyType, @StrictNonNull QMetaType valueType, Map.Entry... entries) {
QMultiHash result = new QMultiHash<>(keyType, valueType);
for (Map.Entry entry : entries) {
result.insert(entry.getKey(), entry.getValue());
}
return result;
}
/**
* Returns a QMultiHash containing keys and values extracted from the given pairs.
*
* @apiNote
* It is convenient to create the pair using the {@link QPair#pair(Object, Object)} method.
* For example,
*
* {@code
* import static java.util.QPair.pair;
*
* QMultiHash map = QMultiHash.ofTypedPairs(
* int.class,
* String.class,
* pair(1, "a"),
* pair(2, "b"),
* pair(3, "c"),
* ...
* pair(26, "z"));
* }
*
* @param the {@code QMultiHash}'s key type
* @param the {@code QMultiHash}'s value type
* @param pairs {@code QPair}s containing the keys and values from which the map is populated
* @return a {@code QMultiHash} containing the specified mappings
* @throws NullPointerException if any pair, key, or value is {@code null}, or if
* the {@code pairs} array is {@code null}
*/
@SafeVarargs
public static @NonNull QMultiHash ofTypedPairs(@Nullable Class keyType, @Nullable Class valueType, QPair... pairs) {
QPair metaTypes = QMap.findMapMetaType(keyType, valueType, pairs);
return ofTypedPairs(metaTypes.first, metaTypes.second, pairs);
}
/**
* Returns a QMultiHash containing keys and values extracted from the given pairs.
*
* @apiNote
* It is convenient to create the pair using the {@link QPair#pair(Object, Object)} method.
* For example,
*
* {@code
* import static java.util.QPair.pair;
*
* QMultiHash