You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by pa...@apache.org on 2017/05/26 00:04:52 UTC
[1/9] groovy git commit: Minor refactoring
Repository: groovy
Updated Branches:
refs/heads/GROOVY_2_6_X d865d968d -> 27562c34f
Minor refactoring
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/ecd46652
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/ecd46652
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/ecd46652
Branch: refs/heads/GROOVY_2_6_X
Commit: ecd46652417e28d843cfbed11d1d5d9462bf2bce
Parents: d865d96
Author: sunlan <su...@apache.org>
Authored: Sat May 6 01:44:14 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:21 2017 +1000
----------------------------------------------------------------------
.../groovy/classgen/asm/WriterController.java | 23 ++++++++------------
.../groovy/control/CompilerConfiguration.java | 12 ++++++++++
2 files changed, 21 insertions(+), 14 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/ecd46652/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/classgen/asm/WriterController.java b/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
index e8c5b61..0c80b8e 100644
--- a/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
+++ b/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
@@ -19,6 +19,8 @@
package org.codehaus.groovy.classgen.asm;
import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.codehaus.groovy.GroovyBugError;
@@ -39,6 +41,8 @@ import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
+import static org.codehaus.groovy.control.CompilerConfiguration.JDK_TO_BYTECODE_VERSION_MAP;
+
public class WriterController {
private AsmClassGenerator acg;
@@ -135,22 +139,13 @@ public class WriterController {
}
return Opcodes.V1_7;
} else {
- if (CompilerConfiguration.JDK4.equals(targetBytecode)) {
- return Opcodes.V1_4;
- }
- if (CompilerConfiguration.JDK5.equals(targetBytecode)) {
- return Opcodes.V1_5;
- }
- if (CompilerConfiguration.JDK6.equals(targetBytecode)) {
- return Opcodes.V1_6;
- }
- if (CompilerConfiguration.JDK7.equals(targetBytecode)) {
- return Opcodes.V1_7;
- }
- if (CompilerConfiguration.JDK8.equals(targetBytecode)) {
- return Opcodes.V1_8;
+ Integer bytecodeVersion = JDK_TO_BYTECODE_VERSION_MAP.get(targetBytecode);
+
+ if (null != bytecodeVersion) {
+ return bytecodeVersion;
}
}
+
throw new GroovyBugError("Bytecode version ["+targetBytecode+"] is not supported by the compiler");
}
http://git-wip-us.apache.org/repos/asf/groovy/blob/ecd46652/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
index a2650b6..8b1bff2 100644
--- a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
+++ b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
@@ -21,6 +21,7 @@ package org.codehaus.groovy.control;
import org.codehaus.groovy.control.customizers.CompilationCustomizer;
import org.codehaus.groovy.control.io.NullWriter;
import org.codehaus.groovy.control.messages.WarningMessage;
+import org.objectweb.asm.Opcodes;
import java.io.File;
import java.io.PrintWriter;
@@ -60,6 +61,17 @@ public class CompilerConfiguration {
/** An array of the valid targetBytecode values **/
public static final String[] ALLOWED_JDKS = { JDK4, JDK5, JDK6, JDK7, JDK8 };
+ /**
+ * JDK version to bytecode version mapping
+ */
+ public static final Map<String, Integer> JDK_TO_BYTECODE_VERSION_MAP = Collections.unmodifiableMap(new HashMap<String, Integer>() {{
+ put(JDK4, Opcodes.V1_4);
+ put(JDK5, Opcodes.V1_5);
+ put(JDK6, Opcodes.V1_6);
+ put(JDK7, Opcodes.V1_7);
+ put(JDK8, Opcodes.V1_8);
+ }});
+
// Just call getVMVersion() once.
public static final String currentJVMVersion = getVMVersion();
[9/9] groovy git commit: Refine node position of statements
Posted by pa...@apache.org.
Refine node position of statements
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/27562c34
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/27562c34
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/27562c34
Branch: refs/heads/GROOVY_2_6_X
Commit: 27562c34fff1d2dd461db8bd8d0aafbfe53a0d7b
Parents: 604f577
Author: sunlan <su...@apache.org>
Authored: Thu May 25 21:42:10 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:33 2017 +1000
----------------------------------------------------------------------
.../groovy/ast/LineColumnCheck_antlr4.txt | 2 +-
.../apache/groovy/parser/antlr4/GroovyParser.g4 | 14 ++++++++-----
.../apache/groovy/parser/antlr4/AstBuilder.java | 22 ++++++++++++--------
3 files changed, 23 insertions(+), 15 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/27562c34/src/test/org/codehaus/groovy/ast/LineColumnCheck_antlr4.txt
----------------------------------------------------------------------
diff --git a/src/test/org/codehaus/groovy/ast/LineColumnCheck_antlr4.txt b/src/test/org/codehaus/groovy/ast/LineColumnCheck_antlr4.txt
index 6f26726..4eb0cb8 100644
--- a/src/test/org/codehaus/groovy/ast/LineColumnCheck_antlr4.txt
+++ b/src/test/org/codehaus/groovy/ast/LineColumnCheck_antlr4.txt
@@ -24,7 +24,7 @@ if (expression) {
}
:::[IfStatement,(1:1),(5:2)];
-[BooleanExpression,(1:4),(1:16)][VariableExpression,(1:4),(1:16)];
+[BooleanExpression,(1:5),(1:15)][VariableExpression,(1:5),(1:15)];
[BlockStatement,(1:17),(3:2)];
[BlockStatement,(3:8),(5:2)]
http://git-wip-us.apache.org/repos/asf/groovy/blob/27562c34/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4 b/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
index 08cdbe2..3e6bc07 100644
--- a/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
+++ b/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
@@ -624,14 +624,14 @@ variableNames
switchStatement
locals[ String footprint = "" ]
- : SWITCH parExpression nls LBRACE nls switchBlockStatementGroup* nls RBRACE
+ : SWITCH expressionInPar nls LBRACE nls switchBlockStatementGroup* nls RBRACE
;
loopStatement
locals[ String footprint = "" ]
: FOR LPAREN forControl rparen nls statement #forStmtAlt
- | WHILE parExpression nls statement #whileStmtAlt
- | DO nls statement nls WHILE parExpression #doWhileStmtAlt
+ | WHILE expressionInPar nls statement #whileStmtAlt
+ | DO nls statement nls WHILE expressionInPar #doWhileStmtAlt
;
continueStatement
@@ -690,13 +690,13 @@ locals[ String footprint = "" ]
statement
: block #blockStmtAlt
- | IF parExpression nls tb=statement ((nls | sep) ELSE nls fb=statement)? #ifElseStmtAlt
+ | IF expressionInPar nls tb=statement ((nls | sep) ELSE nls fb=statement)? #ifElseStmtAlt
| loopStatement #loopStmtAlt
| tryCatchStatement #tryCatchStmtAlt
| switchStatement #switchStmtAlt
- | SYNCHRONIZED parExpression nls block #synchronizedStmtAlt
+ | SYNCHRONIZED expressionInPar nls block #synchronizedStmtAlt
| RETURN expression? #returnStmtAlt
| THROW expression #throwStmtAlt
@@ -791,6 +791,10 @@ castParExpression
;
parExpression
+ : expressionInPar
+ ;
+
+expressionInPar
: LPAREN enhancedStatementExpression rparen
;
http://git-wip-us.apache.org/repos/asf/groovy/blob/27562c34/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index 471b5de..2feec71 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -362,7 +362,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
@Override
public IfStatement visitIfElseStmtAlt(IfElseStmtAltContext ctx) {
- Expression conditionExpression = this.visitParExpression(ctx.parExpression());
+ Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());
BooleanExpression booleanExpression =
this.configureAST(
new BooleanExpression(conditionExpression), conditionExpression);
@@ -476,7 +476,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
@Override
public WhileStatement visitWhileStmtAlt(WhileStmtAltContext ctx) {
- Expression conditionExpression = this.visitParExpression(ctx.parExpression());
+ Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());
BooleanExpression booleanExpression =
this.configureAST(
new BooleanExpression(conditionExpression), conditionExpression);
@@ -490,7 +490,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
@Override
public DoWhileStatement visitDoWhileStmtAlt(DoWhileStmtAltContext ctx) {
- Expression conditionExpression = this.visitParExpression(ctx.parExpression());
+ Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());
BooleanExpression booleanExpression =
this.configureAST(
@@ -674,7 +674,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
return this.configureAST(
new SwitchStatement(
- this.visitParExpression(ctx.parExpression()),
+ this.visitExpressionInPar(ctx.expressionInPar()),
caseStatementList,
defaultStatementListSize == 0 ? EmptyStatement.INSTANCE : defaultStatementList.get(0)
),
@@ -742,15 +742,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
throw createParsingFailedException("Unsupported switch label: " + ctx.getText(), ctx);
}
-
@Override
public SynchronizedStatement visitSynchronizedStmtAlt(SynchronizedStmtAltContext ctx) {
return this.configureAST(
- new SynchronizedStatement(this.visitParExpression(ctx.parExpression()), this.visitBlock(ctx.block())),
+ new SynchronizedStatement(this.visitExpressionInPar(ctx.expressionInPar()), this.visitBlock(ctx.block())),
ctx);
}
-
@Override
public ExpressionStatement visitExpressionStmtAlt(ExpressionStmtAltContext ctx) {
return (ExpressionStatement) this.visit(ctx.statementExpression());
@@ -1846,7 +1844,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
@Override
public Expression visitParExpression(ParExpressionContext ctx) {
- Expression expression = this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression());
+ Expression expression = this.visitExpressionInPar(ctx.expressionInPar());
expression.putNodeMetaData(IS_INSIDE_PARENTHESES, true);
@@ -1861,7 +1859,13 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
return this.configureAST(expression, ctx);
}
- @Override public Expression visitEnhancedStatementExpression(EnhancedStatementExpressionContext ctx) {
+ @Override
+ public Expression visitExpressionInPar(ExpressionInParContext ctx) {
+ return this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression());
+ }
+
+ @Override
+ public Expression visitEnhancedStatementExpression(EnhancedStatementExpressionContext ctx) {
Expression expression;
if (asBoolean(ctx.statementExpression())) {
[5/9] groovy git commit: Minor refactoring(provide type safe way to
build maps)
Posted by pa...@apache.org.
http://git-wip-us.apache.org/repos/asf/groovy/blob/cc825078/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>
[7/9] groovy git commit: Make field STANDARD_ESCAPES final
Posted by pa...@apache.org.
Make field STANDARD_ESCAPES final
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/b8041d85
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/b8041d85
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/b8041d85
Branch: refs/heads/GROOVY_2_6_X
Commit: b8041d853304dac7e8fe6262eb6e002f7b6d6d3c
Parents: cc82507
Author: sunlan <su...@apache.org>
Authored: Sun May 21 00:33:48 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:29 2017 +1000
----------------------------------------------------------------------
.../java/org/apache/groovy/parser/antlr4/util/StringUtils.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/b8041d85/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
index 5b2a311..1a37cdf 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
@@ -59,7 +59,7 @@ public class StringUtils {
});
}
- private static Map<Character, Character> STANDARD_ESCAPES = Maps.of(
+ private static final Map<Character, Character> STANDARD_ESCAPES = Maps.of(
'b', '\b',
't', '\t',
'n', '\n',
[4/9] groovy git commit: Add license header to Maps
Posted by pa...@apache.org.
Add license header to Maps
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/71b4b001
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/71b4b001
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/71b4b001
Branch: refs/heads/GROOVY_2_6_X
Commit: 71b4b001a8763662fe7f4ce464ba69afd1c1f3ab
Parents: 1269bcc
Author: sunlan <su...@apache.org>
Authored: Sat May 20 22:59:35 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:26 2017 +1000
----------------------------------------------------------------------
src/main/org/apache/groovy/util/Maps.java | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/71b4b001/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 e94005c..0ad3d2c 100644
--- a/src/main/org/apache/groovy/util/Maps.java
+++ b/src/main/org/apache/groovy/util/Maps.java
@@ -1,3 +1,21 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
package org.apache.groovy.util;
import java.util.Collections;
[8/9] groovy git commit: Minor refactoring
Posted by pa...@apache.org.
Minor refactoring
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/604f5776
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/604f5776
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/604f5776
Branch: refs/heads/GROOVY_2_6_X
Commit: 604f5776bc1c01fe8c86ebc5d6f5298a7e561e5e
Parents: b8041d8
Author: sunlan <su...@apache.org>
Authored: Thu May 25 20:21:05 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:31 2017 +1000
----------------------------------------------------------------------
.../apache/groovy/parser/antlr4/GroovyParser.g4 | 14 ++++--
.../apache/groovy/parser/antlr4/AstBuilder.java | 48 +++++++++-----------
2 files changed, 30 insertions(+), 32 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/604f5776/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4 b/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
index 3949350..08cdbe2 100644
--- a/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
+++ b/subprojects/parser-antlr4/src/main/antlr4/org/apache/groovy/parser/antlr4/GroovyParser.g4
@@ -364,8 +364,7 @@ variableDeclaratorId
;
variableInitializer
- : statementExpression
- | standardLambda
+ : enhancedStatementExpression
;
variableInitializers
@@ -679,7 +678,7 @@ locals[boolean resourcesExists = false]
|
nls finallyBlock
|
- // a catch or finally clause is required unless it's try-with-resources
+ // try-with-resources can have no catche and finally clauses
{ $resourcesExists }?<fail={"catch or finally clauses are required for try-catch statement"}>
)
;
@@ -792,7 +791,12 @@ castParExpression
;
parExpression
- : LPAREN (statementExpression | standardLambda) rparen
+ : LPAREN enhancedStatementExpression rparen
+ ;
+
+enhancedStatementExpression
+ : statementExpression
+ | standardLambda
;
expressionList[boolean canSpread]
@@ -920,7 +924,7 @@ expression
| POWER_ASSIGN
| ELVIS_ASSIGN
) nls
- (statementExpression | standardLambda) #assignmentExprAlt
+ enhancedStatementExpression #assignmentExprAlt
;
commandExpression
http://git-wip-us.apache.org/repos/asf/groovy/blob/604f5776/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index 79b3d90..471b5de 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -128,7 +128,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
@@ -1683,17 +1682,9 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
return EmptyExpression.INSTANCE;
}
- if (asBoolean(ctx.statementExpression())) {
- return this.configureAST(
- ((ExpressionStatement) this.visit(ctx.statementExpression())).getExpression(),
- ctx);
- }
-
- if (asBoolean(ctx.standardLambda())) {
- return this.configureAST(this.visitStandardLambda(ctx.standardLambda()), ctx);
- }
-
- throw createParsingFailedException("Unsupported variable initializer: " + ctx.getText(), ctx);
+ return this.configureAST(
+ this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression()),
+ ctx);
}
@Override
@@ -1855,15 +1846,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
@Override
public Expression visitParExpression(ParExpressionContext ctx) {
- Expression expression;
-
- if (asBoolean(ctx.statementExpression())) {
- expression = ((ExpressionStatement) this.visit(ctx.statementExpression())).getExpression();
- } else if (asBoolean(ctx.standardLambda())) {
- expression = this.visitStandardLambda(ctx.standardLambda());
- } else {
- throw createParsingFailedException("Unsupported parentheses expression: " + ctx.getText(), ctx);
- }
+ Expression expression = this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression());
expression.putNodeMetaData(IS_INSIDE_PARENTHESES, true);
@@ -1878,6 +1861,21 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
return this.configureAST(expression, ctx);
}
+ @Override public Expression visitEnhancedStatementExpression(EnhancedStatementExpressionContext ctx) {
+ Expression expression;
+
+ if (asBoolean(ctx.statementExpression())) {
+ expression = ((ExpressionStatement) this.visit(ctx.statementExpression())).getExpression();
+ } else if (asBoolean(ctx.standardLambda())) {
+ expression = this.visitStandardLambda(ctx.standardLambda());
+ } else {
+ throw createParsingFailedException("Unsupported enhanced statement expression: " + ctx.getText(), ctx);
+ }
+
+ return this.configureAST(expression, ctx);
+ }
+
+
@Override
public Expression visitPathExpression(PathExpressionContext ctx) {
return this.configureAST(
@@ -2631,9 +2629,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
new BinaryExpression(
this.configureAST(new TupleExpression(leftExpr), ctx.left),
this.createGroovyToken(ctx.op),
- asBoolean(ctx.statementExpression())
- ? ((ExpressionStatement) this.visit(ctx.statementExpression())).getExpression()
- : this.visitStandardLambda(ctx.standardLambda())),
+ this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression())),
ctx);
}
@@ -2660,9 +2656,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
new BinaryExpression(
leftExpr,
this.createGroovyToken(ctx.op),
- asBoolean(ctx.statementExpression())
- ? ((ExpressionStatement) this.visit(ctx.statementExpression())).getExpression()
- : this.visitStandardLambda(ctx.standardLambda())),
+ this.visitEnhancedStatementExpression(ctx.enhancedStatementExpression())),
ctx);
}
[3/9] groovy git commit: Minor refactoring
Posted by pa...@apache.org.
Minor refactoring
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/1269bcc6
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/1269bcc6
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/1269bcc6
Branch: refs/heads/GROOVY_2_6_X
Commit: 1269bcc62dc2fef5044b80e9fb1ab54d19d87fb8
Parents: 4e84d7e
Author: sunlan <su...@apache.org>
Authored: Sat May 20 22:34:30 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:24 2017 +1000
----------------------------------------------------------------------
src/main/org/apache/groovy/util/Maps.java | 28 ++++++++++++++
.../groovy/control/CompilerConfiguration.java | 15 ++++----
.../apache/groovy/parser/antlr4/AstBuilder.java | 23 ++++++------
.../groovy/parser/antlr4/ModifierManager.java | 11 +++---
.../groovy/parser/antlr4/ModifierNode.java | 39 ++++++++++----------
.../parser/antlr4/internal/AtnManager.java | 12 +++---
.../groovy/parser/antlr4/util/StringUtils.java | 17 ++++-----
7 files changed, 84 insertions(+), 61 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/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
new file mode 100644
index 0000000..e94005c
--- /dev/null
+++ b/src/main/org/apache/groovy/util/Maps.java
@@ -0,0 +1,28 @@
+package org.apache.groovy.util;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+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");
+ }
+
+ Map map = new LinkedHashMap();
+
+ for (int i = 0, n = length / 2; i < n; i++) {
+ int index = i * 2;
+
+ map.put(args[index], args[index + 1]);
+ }
+
+ return Collections.unmodifiableMap(map);
+ }
+}
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
index 9ea99e6..17ac7cf 100644
--- a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
+++ b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
@@ -18,6 +18,7 @@
*/
package org.codehaus.groovy.control;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.control.customizers.CompilationCustomizer;
import org.codehaus.groovy.control.io.NullWriter;
import org.codehaus.groovy.control.messages.WarningMessage;
@@ -72,13 +73,13 @@ public class CompilerConfiguration {
/**
* JDK version to bytecode version mapping
*/
- public static final Map<String, Integer> JDK_TO_BYTECODE_VERSION_MAP = Collections.unmodifiableMap(new LinkedHashMap<String, Integer>() {{
- put(JDK4, Opcodes.V1_4);
- put(JDK5, Opcodes.V1_5);
- put(JDK6, Opcodes.V1_6);
- put(JDK7, Opcodes.V1_7);
- put(JDK8, Opcodes.V1_8);
- }});
+ public static final Map<String, Integer> JDK_TO_BYTECODE_VERSION_MAP = Maps.of(
+ JDK4, Opcodes.V1_4,
+ JDK5, Opcodes.V1_5,
+ JDK6, Opcodes.V1_6,
+ JDK7, Opcodes.V1_7,
+ JDK8, Opcodes.V1_8
+ );
/** An array of the valid targetBytecode values **/
public static final String[] ALLOWED_JDKS = JDK_TO_BYTECODE_VERSION_MAP.keySet().toArray(new String[0]);
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index f50af1c..79b3d90 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -32,6 +32,7 @@ import org.antlr.v4.runtime.tree.TerminalNode;
import org.apache.groovy.parser.antlr4.internal.AtnManager;
import org.apache.groovy.parser.antlr4.internal.DescriptiveErrorStrategy;
import org.apache.groovy.parser.antlr4.util.StringUtils;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.antlr.EnumHelper;
import org.codehaus.groovy.ast.ASTNode;
@@ -3984,18 +3985,16 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> implements Groov
}
}
- private static final Map<ClassNode, Object> TYPE_DEFAULT_VALUE_MAP = Collections.unmodifiableMap(new HashMap<ClassNode, Object>() {
- {
- this.put(ClassHelper.int_TYPE, 0);
- this.put(ClassHelper.long_TYPE, 0L);
- this.put(ClassHelper.double_TYPE, 0.0D);
- this.put(ClassHelper.float_TYPE, 0.0F);
- this.put(ClassHelper.short_TYPE, (short) 0);
- this.put(ClassHelper.byte_TYPE, (byte) 0);
- this.put(ClassHelper.char_TYPE, (char) 0);
- this.put(ClassHelper.boolean_TYPE, Boolean.FALSE);
- }
- });
+ private static final Map<ClassNode, Object> TYPE_DEFAULT_VALUE_MAP = Maps.of(
+ ClassHelper.int_TYPE, 0,
+ ClassHelper.long_TYPE, 0L,
+ ClassHelper.double_TYPE, 0.0D,
+ ClassHelper.float_TYPE, 0.0F,
+ ClassHelper.short_TYPE, (short) 0,
+ ClassHelper.byte_TYPE, (byte) 0,
+ ClassHelper.char_TYPE, (char) 0,
+ ClassHelper.boolean_TYPE, Boolean.FALSE
+ );
private Object findDefaultValueByType(ClassNode type) {
return TYPE_DEFAULT_VALUE_MAP.get(type);
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
index 23ce68e..22d6d69 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierManager.java
@@ -18,6 +18,7 @@
*/
package org.apache.groovy.parser.antlr4;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.ast.AnnotatedNode;
import org.codehaus.groovy.ast.AnnotationNode;
import org.codehaus.groovy.ast.ConstructorNode;
@@ -45,12 +46,10 @@ import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
* Created by Daniel.Sun on 2016/08/27.
*/
class ModifierManager {
- private static final Map<Class, List<Integer>> INVALID_MODIFIERS_MAP = Collections.unmodifiableMap(new HashMap<Class, List<Integer>>() {
- {
- put(ConstructorNode.class, Arrays.asList(STATIC, FINAL, ABSTRACT, NATIVE));
- put(MethodNode.class, Arrays.asList(VOLATILE/*, TRANSIENT*/));
- }
- });
+ private static final Map<Class, List<Integer>> INVALID_MODIFIERS_MAP = Maps.of(
+ ConstructorNode.class, Arrays.asList(STATIC, FINAL, ABSTRACT, NATIVE),
+ MethodNode.class, Arrays.asList(VOLATILE/*, TRANSIENT*/)
+ );
private AstBuilder astBuilder;
private List<ModifierNode> modifierNodeList;
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierNode.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierNode.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierNode.java
index 5d1007b..65a2f31 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierNode.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/ModifierNode.java
@@ -18,6 +18,7 @@
*/
package org.apache.groovy.parser.antlr4;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.AnnotationNode;
import org.objectweb.asm.Opcodes;
@@ -43,26 +44,24 @@ public class ModifierNode extends ASTNode {
private boolean repeatable;
public static final int ANNOTATION_TYPE = -999;
- public static final Map<Integer, Integer> MODIFIER_OPCODE_MAP = Collections.unmodifiableMap(new HashMap<Integer, Integer>() {
- {
- put(ANNOTATION_TYPE, 0);
- put(DEF, 0);
-
- put(NATIVE, Opcodes.ACC_NATIVE);
- put(SYNCHRONIZED, Opcodes.ACC_SYNCHRONIZED);
- put(TRANSIENT, Opcodes.ACC_TRANSIENT);
- put(VOLATILE, Opcodes.ACC_VOLATILE);
-
- put(PUBLIC, Opcodes.ACC_PUBLIC);
- put(PROTECTED, Opcodes.ACC_PROTECTED);
- put(PRIVATE, Opcodes.ACC_PRIVATE);
- put(STATIC, Opcodes.ACC_STATIC);
- put(ABSTRACT, Opcodes.ACC_ABSTRACT);
- put(FINAL, Opcodes.ACC_FINAL);
- put(STRICTFP, Opcodes.ACC_STRICT);
- put(DEFAULT, 0); // no flag for specifying a default method in the JVM spec, hence no ACC_DEFAULT flag in ASM
- }
- });
+ public static final Map<Integer, Integer> MODIFIER_OPCODE_MAP = Maps.of(
+ ANNOTATION_TYPE, 0,
+ DEF, 0,
+
+ NATIVE, Opcodes.ACC_NATIVE,
+ SYNCHRONIZED, Opcodes.ACC_SYNCHRONIZED,
+ TRANSIENT, Opcodes.ACC_TRANSIENT,
+ VOLATILE, Opcodes.ACC_VOLATILE,
+
+ PUBLIC, Opcodes.ACC_PUBLIC,
+ PROTECTED, Opcodes.ACC_PROTECTED,
+ PRIVATE, Opcodes.ACC_PRIVATE,
+ STATIC, Opcodes.ACC_STATIC,
+ ABSTRACT, Opcodes.ACC_ABSTRACT,
+ FINAL, Opcodes.ACC_FINAL,
+ STRICTFP, Opcodes.ACC_STRICT,
+ DEFAULT, 0 // no flag for specifying a default method in the JVM spec, hence no ACC_DEFAULT flag in ASM
+ );
public ModifierNode(Integer type) {
this.type = type;
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/internal/AtnManager.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/internal/AtnManager.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/internal/AtnManager.java
index 02cc152..11dfdb5 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/internal/AtnManager.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/internal/AtnManager.java
@@ -21,6 +21,7 @@ package org.apache.groovy.parser.antlr4.internal;
import org.antlr.v4.runtime.atn.ATN;
import org.apache.groovy.parser.antlr4.GroovyLangLexer;
import org.apache.groovy.parser.antlr4.GroovyLangParser;
+import org.apache.groovy.util.Maps;
import java.util.Collections;
import java.util.HashMap;
@@ -40,13 +41,10 @@ public class AtnManager {
private static final int CACHE_THRESHOLD;
private final Class ownerClass;
private final ATN atn;
- private static final Map<Class, AtnWrapper> ATN_MAP =
- Collections.unmodifiableMap(new HashMap<Class, AtnWrapper>() {
- {
- put(GroovyLangLexer.class, new AtnWrapper(GroovyLangLexer._ATN));
- put(GroovyLangParser.class, new AtnWrapper(GroovyLangParser._ATN));
- }
- });
+ private static final Map<Class, AtnWrapper> ATN_MAP = Maps.of(
+ GroovyLangLexer.class, new AtnWrapper(GroovyLangLexer._ATN),
+ GroovyLangParser.class, new AtnWrapper(GroovyLangParser._ATN)
+ );
static {
int t = 50;
http://git-wip-us.apache.org/repos/asf/groovy/blob/1269bcc6/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
----------------------------------------------------------------------
diff --git a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
index 980facb..5b2a311 100644
--- a/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
+++ b/subprojects/parser-antlr4/src/main/java/org/apache/groovy/parser/antlr4/util/StringUtils.java
@@ -19,6 +19,7 @@
package org.apache.groovy.parser.antlr4.util;
import groovy.lang.Closure;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.runtime.StringGroovyMethods;
import java.util.HashMap;
@@ -58,15 +59,13 @@ public class StringUtils {
});
}
- private static Map<Character, Character> STANDARD_ESCAPES = new HashMap<Character, Character>() {
- {
- this.put('b', '\b');
- this.put('t', '\t');
- this.put('n', '\n');
- this.put('f', '\f');
- this.put('r', '\r');
- }
- };
+ private static Map<Character, Character> STANDARD_ESCAPES = Maps.of(
+ 'b', '\b',
+ 't', '\t',
+ 'n', '\n',
+ 'f', '\f',
+ 'r', '\r'
+ );
public static String replaceStandardEscapes(String text) {
Pattern p = Pattern.compile("(\\\\*)\\\\([btnfr\"'])");
[2/9] groovy git commit: Minor refactoring
Posted by pa...@apache.org.
Minor refactoring
Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/4e84d7e2
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/4e84d7e2
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/4e84d7e2
Branch: refs/heads/GROOVY_2_6_X
Commit: 4e84d7e28082e481a6d69b86aa64a011f01b0264
Parents: ecd4665
Author: sunlan <su...@apache.org>
Authored: Mon May 8 00:34:08 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:22 2017 +1000
----------------------------------------------------------------------
.../groovy/classgen/asm/WriterController.java | 11 ++++------
.../groovy/control/CompilerConfiguration.java | 21 +++++++++++++++-----
2 files changed, 20 insertions(+), 12 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/groovy/blob/4e84d7e2/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/classgen/asm/WriterController.java b/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
index 0c80b8e..386ec1f 100644
--- a/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
+++ b/src/main/org/codehaus/groovy/classgen/asm/WriterController.java
@@ -18,11 +18,6 @@
*/
package org.codehaus.groovy.classgen.asm;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
@@ -41,7 +36,9 @@ import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
-import static org.codehaus.groovy.control.CompilerConfiguration.JDK_TO_BYTECODE_VERSION_MAP;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
public class WriterController {
@@ -139,7 +136,7 @@ public class WriterController {
}
return Opcodes.V1_7;
} else {
- Integer bytecodeVersion = JDK_TO_BYTECODE_VERSION_MAP.get(targetBytecode);
+ Integer bytecodeVersion = CompilerConfiguration.JDK_TO_BYTECODE_VERSION_MAP.get(targetBytecode);
if (null != bytecodeVersion) {
return bytecodeVersion;
http://git-wip-us.apache.org/repos/asf/groovy/blob/4e84d7e2/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
----------------------------------------------------------------------
diff --git a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
index 8b1bff2..9ea99e6 100644
--- a/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
+++ b/src/main/org/codehaus/groovy/control/CompilerConfiguration.java
@@ -25,7 +25,18 @@ import org.objectweb.asm.Opcodes;
import java.io.File;
import java.io.PrintWriter;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.StringTokenizer;
/**
* Compilation control flags and coordination stuff.
@@ -58,13 +69,10 @@ public class CompilerConfiguration {
/** This (<code>"1.4"</code>) is the value for targetBytecode to compile for a JDK 1.4 JVM. **/
public static final String PRE_JDK5 = JDK4;
- /** An array of the valid targetBytecode values **/
- public static final String[] ALLOWED_JDKS = { JDK4, JDK5, JDK6, JDK7, JDK8 };
-
/**
* JDK version to bytecode version mapping
*/
- public static final Map<String, Integer> JDK_TO_BYTECODE_VERSION_MAP = Collections.unmodifiableMap(new HashMap<String, Integer>() {{
+ public static final Map<String, Integer> JDK_TO_BYTECODE_VERSION_MAP = Collections.unmodifiableMap(new LinkedHashMap<String, Integer>() {{
put(JDK4, Opcodes.V1_4);
put(JDK5, Opcodes.V1_5);
put(JDK6, Opcodes.V1_6);
@@ -72,6 +80,9 @@ public class CompilerConfiguration {
put(JDK8, Opcodes.V1_8);
}});
+ /** An array of the valid targetBytecode values **/
+ public static final String[] ALLOWED_JDKS = JDK_TO_BYTECODE_VERSION_MAP.keySet().toArray(new String[0]);
+
// Just call getVMVersion() once.
public static final String currentJVMVersion = getVMVersion();
[6/9] groovy git commit: Minor refactoring(provide type safe way to
build maps)
Posted by pa...@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/cc825078
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/cc825078
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/cc825078
Branch: refs/heads/GROOVY_2_6_X
Commit: cc825078b0d8a09a04e13add6ecd110e705ed29f
Parents: 71b4b00
Author: sunlan <su...@apache.org>
Authored: Sun May 21 00:05:47 2017 +0800
Committer: paulk <pa...@asert.com.au>
Committed: Fri May 26 10:04:27 2017 +1000
----------------------------------------------------------------------
src/main/org/apache/groovy/util/Maps.java | 5754 +++++++++++++++++++++++-
1 file changed, 5744 insertions(+), 10 deletions(-)
----------------------------------------------------------------------