diff -r 1c96344ecd49 -r 65ec6de1d6b4 langtools/src/jdk.jshell/share/classes/jdk/jshell/Key.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/src/jdk.jshell/share/classes/jdk/jshell/Key.java Mon Oct 19 19:15:16 2015 +0200 @@ -0,0 +1,290 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package jdk.jshell; + +import jdk.jshell.Snippet.Kind; +import jdk.jshell.Snippet.SubKind; + +/** + * The Key is unique for a given signature. Used internal to the implementation + * to group signature matched Snippets. Snippet kinds without a signature + * (for example expressions) each have their own UniqueKey. + * @author Robert Field + */ +abstract class Key { + + /** + * The unique index for this Key + */ + private final int index; + + /** + * The JShell corresponding to this Key + */ + private final JShell state; + + Key(JShell state) { + this.index = state.nextKeyIndex(); + this.state = state; + } + + /** + * The unique numeric identifier for the snippet. Snippets which replace or + * redefine existing snippets take on the same key index as the replaced or + * redefined snippet. + * The index values are monotonically increasing integers. + * @return the Key index + */ + int index() { return index; } + + /** + * The kind for the key. Indicates the subinterface of Key. + * @return the Kind of the Key + */ + abstract Kind kind(); + + /** + * For foreign key testing. + */ + JShell state() { return state; } + + /** + * Grouping for snippets which persist and influence future code. + * They are keyed off at least the name. They may be Modified/Replaced + * with new input and can be dropped (JShell#drop). + */ + static abstract class PersistentKey extends Key { + + private final String name; + + PersistentKey(JShell state, String name) { + super(state); + this.name = name; + } + /** + * Name of the snippet. + * + * @return the name of the snippet. + */ + String name() { return name; } + } + + /** + * Grouping for snippets which reference declarations + */ + static abstract class DeclarationKey extends PersistentKey { + + DeclarationKey(JShell state, String name) { + super(state, name); + } + } + + /** + * Key for a class definition Keys of TYPE_DECL. Keyed off class name. + */ + static class TypeDeclKey extends DeclarationKey { + + TypeDeclKey(JShell state, String name) { + super(state, name); + } + + @Override + Kind kind() { return Kind.TYPE_DECL; } + + @Override + public String toString() { return "ClassKey(" + name() + ")#" + index(); } + } + + /** + * Key for a method definition Keys of METHOD. Keyed off method name and + * parameter types. + */ + static class MethodKey extends DeclarationKey { + + private final String parameterTypes; + + MethodKey(JShell state, String name, String parameterTypes) { + super(state, name); + this.parameterTypes = parameterTypes; + } + + @Override + Kind kind() { return Kind.METHOD; } + + /** + * The parameter types of the method. Because of overloading of methods, + * the parameter types are part of the key. + * + * @return a String representation of the parameter types of the method. + */ + String parameterTypes() { return parameterTypes; } + + + @Override + public String toString() { return "MethodKey(" + name() + + "(" + parameterTypes() + "))#" + index(); } + } + + /** + * Key for a variable definition Keys of VARIABLE. Keyed off variable + * name. + */ + static class VarKey extends DeclarationKey { + + VarKey(JShell state, String name) { + super(state, name); + } + + @Override + public Kind kind() { return Kind.VAR; } + + @Override + public String toString() { return "VariableKey(" + name() + ")#" + index(); } + } + + /** + * Key for an import. Keys of IMPORT. Keyed off import text and whether + * import is static. + */ + static class ImportKey extends PersistentKey { + + private final SubKind snippetKind; + + ImportKey(JShell state, String name,SubKind snippetKind) { + super(state, name); + this.snippetKind = snippetKind; + } + + @Override + public Kind kind() { return Kind.IMPORT; } + + /** + * Which kind of import. + * + * @return the appropriate SubKind. + */ + SubKind snippetKind() { + return snippetKind; + } + + + @Override + public String toString() { return "ImportKey(" + name() + "," + + snippetKind + ")#" + index(); } + } + + /** + * Grouping for snippets which are the key for only one input -- even if the + * exactly same entry is made again. The referenced snippets are thus + * unmodifiable. + */ + static abstract class UniqueKey extends Key { + + UniqueKey(JShell state) { + super(state); + } + } + + /** + * Key for a statement snippet. Keys of STATEMENT. Uniquely keyed, see + * UniqueKey. + */ + static class StatementKey extends UniqueKey { + + StatementKey(JShell state) { + super(state); + } + + + @Override + public Kind kind() { + return Kind.STATEMENT; + } + + @Override + public String toString() { return "StatementKey#" + index(); } + } + + /** + * Key for an expression. Keys of EXPRESSION. Uniquely keyed, see + * UniqueKey. + */ + static class ExpressionKey extends UniqueKey { + + private final String name; + private final String typeName; + + ExpressionKey(JShell state, String name, String typeName) { + super(state); + this.name = name; + this.typeName = typeName; + } + + @Override + public Kind kind() { return Kind.EXPRESSION; } + + + /** + * Variable name which is the value of the expression. Since the + * expression is either just an identifier which is a variable or it is + * an assignment to a variable, there is always a variable which is the + * subject of the expression. All other expression snippets become + * temporary variables referenced by a VariableKey. + * + * @return the name of the variable which is the subject of the + * expression. + */ + String name() { return name; } + + /** + * Type of the expression + * + * @return String representation of the type of the expression. + */ + String typeName() { return typeName; } + + + @Override + public String toString() { return "ExpressionKey(" + name() + ")#" + index(); } + } + + /** + * Key for an erroneous snippet. Keys of ERRONEOUS. Uniquely keyed, see + * UniqueKey. + */ + static class ErroneousKey extends UniqueKey { + + ErroneousKey(JShell state) { + super(state); + } + + @Override + Kind kind() { return Kind.ERRONEOUS; } + + @Override + public String toString() { return "ErroneousKey#" + index(); } + } +}