You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2017/05/20 16:06:39 UTC
[1/2] groovy git commit: Minor refactoring(provide type safe way to
build maps)
Repository: groovy
Updated Branches:
refs/heads/master 47d8f4e74 -> d1a54b677
http://git-wip-us.apache.org/repos/asf/groovy/blob/d1a54b67/src/main/org/apache/groovy/util/Maps.java
----------------------------------------------------------------------
diff --git a/src/main/org/apache/groovy/util/Maps.java b/src/main/org/apache/groovy/util/Maps.java
index 0ad3d2c..b866928 100644
--- a/src/main/org/apache/groovy/util/Maps.java
+++ b/src/main/org/apache/groovy/util/Maps.java
@@ -26,21 +26,5755 @@ import java.util.Map;
* Map utilities.
*/
public abstract class Maps {
- public static Map of(Object... args) {
- int length = args.length;
- if (0 != length % 2) {
- throw new IllegalArgumentException("the length of arguments should be a power of 2");
- }
+ public static <K, V> Map<K, V> of(K k1, V v1) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
- Map map = new LinkedHashMap();
+ map.put(k1, v1);
- for (int i = 0, n = length / 2; i < n; i++) {
- int index = i * 2;
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+
+ return Collections.unmodifiableMap(map);
+ }
- map.put(args[index], args[index + 1]);
- }
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+ map.put(k57, v57);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57, K k58, V v58) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+ map.put(k57, v57);
+ map.put(k58, v58);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57, K k58, V v58, K k59, V v59) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+ map.put(k57, v57);
+ map.put(k58, v58);
+ map.put(k59, v59);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57, K k58, V v58, K k59, V v59, K k60, V v60) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+ map.put(k57, v57);
+ map.put(k58, v58);
+ map.put(k59, v59);
+ map.put(k60, v60);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57, K k58, V v58, K k59, V v59, K k60, V v60, K k61, V v61) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ map.put(k28, v28);
+ map.put(k29, v29);
+ map.put(k30, v30);
+ map.put(k31, v31);
+ map.put(k32, v32);
+ map.put(k33, v33);
+ map.put(k34, v34);
+ map.put(k35, v35);
+ map.put(k36, v36);
+ map.put(k37, v37);
+ map.put(k38, v38);
+ map.put(k39, v39);
+ map.put(k40, v40);
+ map.put(k41, v41);
+ map.put(k42, v42);
+ map.put(k43, v43);
+ map.put(k44, v44);
+ map.put(k45, v45);
+ map.put(k46, v46);
+ map.put(k47, v47);
+ map.put(k48, v48);
+ map.put(k49, v49);
+ map.put(k50, v50);
+ map.put(k51, v51);
+ map.put(k52, v52);
+ map.put(k53, v53);
+ map.put(k54, v54);
+ map.put(k55, v55);
+ map.put(k56, v56);
+ map.put(k57, v57);
+ map.put(k58, v58);
+ map.put(k59, v59);
+ map.put(k60, v60);
+ map.put(k61, v61);
+
+ return Collections.unmodifiableMap(map);
+ }
+
+ public static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10, K k11, V v11, K k12, V v12, K k13, V v13, K k14, V v14, K k15, V v15, K k16, V v16, K k17, V v17, K k18, V v18, K k19, V v19, K k20, V v20, K k21, V v21, K k22, V v22, K k23, V v23, K k24, V v24, K k25, V v25, K k26, V v26, K k27, V v27, K k28, V v28, K k29, V v29, K k30, V v30, K k31, V v31, K k32, V v32, K k33, V v33, K k34, V v34, K k35, V v35, K k36, V v36, K k37, V v37, K k38, V v38, K k39, V v39, K k40, V v40, K k41, V v41, K k42, V v42, K k43, V v43, K k44, V v44, K k45, V v45, K k46, V v46, K k47, V v47, K k48, V v48, K k49, V v49, K k50, V v50, K k51, V v51, K k52, V v52, K k53, V v53, K k54, V v54, K k55, V v55, K k56, V v56, K k57, V v57, K k58, V v58, K k59, V v59, K k60, V v60, K k61, V v61, K k62, V v62) {
+ Map<K, V> map = new LinkedHashMap<K, V>();
+
+ map.put(k1, v1);
+ map.put(k2, v2);
+ map.put(k3, v3);
+ map.put(k4, v4);
+ map.put(k5, v5);
+ map.put(k6, v6);
+ map.put(k7, v7);
+ map.put(k8, v8);
+ map.put(k9, v9);
+ map.put(k10, v10);
+ map.put(k11, v11);
+ map.put(k12, v12);
+ map.put(k13, v13);
+ map.put(k14, v14);
+ map.put(k15, v15);
+ map.put(k16, v16);
+ map.put(k17, v17);
+ map.put(k18, v18);
+ map.put(k19, v19);
+ map.put(k20, v20);
+ map.put(k21, v21);
+ map.put(k22, v22);
+ map.put(k23, v23);
+ map.put(k24, v24);
+ map.put(k25, v25);
+ map.put(k26, v26);
+ map.put(k27, v27);
+ m
<TRUNCATED>
[2/2] groovy git commit: Minor refactoring(provide type safe way to
build maps)
Posted by su...@apache.org.
Minor refactoring(provide type safe way to build maps)
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/d1a54b67
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/d1a54b67
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/d1a54b67
Branch: refs/heads/master
Commit: d1a54b6778fecd915cfaf64a3fd32bc5b5a2c5e6
Parents: 47d8f4e
Author: sunlan <su...@apache.org>
Authored: Sun May 21 00:05:47 2017 +0800
Committer: sunlan <su...@apache.org>
Committed: Sun May 21 00:06:30 2017 +0800
----------------------------------------------------------------------
src/main/org/apache/groovy/util/Maps.java | 5754 +++++++++++++++++++++++-
1 file changed, 5744 insertions(+), 10 deletions(-)
----------------------------------------------------------------------