import gnu.trove.THashSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ui.DynamicElementSettings;
import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
return result;
}
- public static List<MyPair> swapArgumentsAndTypes(String[] names, PsiType[] types) {
- List<MyPair> result = new ArrayList<MyPair>();
+ public static List<ParamInfo> swapArgumentsAndTypes(String[] names, PsiType[] types) {
+ List<ParamInfo> result = new ArrayList<ParamInfo>();
if (names.length != types.length) return Collections.emptyList();
String name = names[i];
final PsiType type = types[i];
- result.add(new MyPair(name, type.getCanonicalText()));
+ result.add(new ParamInfo(name, type.getCanonicalText()));
}
return result;
return referenceExpression.getParent() instanceof GrCall;
}
- public static String[] getArgumentsTypes(List<MyPair> listOfPairs) {
+ public static String[] getArgumentsTypes(List<ParamInfo> listOfPairs) {
final List<String> result = new ArrayList<String>();
if (listOfPairs == null) return ArrayUtil.EMPTY_STRING_ARRAY;
- for (MyPair listOfPair : listOfPairs) {
- String type = PsiTypesUtil.unboxIfPossible(listOfPair.second);
+ for (ParamInfo listOfPair : listOfPairs) {
+ String type = PsiTypesUtil.unboxIfPossible(listOfPair.type);
result.add(type);
}
return ArrayUtil.toStringArray(result);
}
- public static String[] getArgumentsNames(List<MyPair> listOfPairs) {
+ public static String[] getArgumentsNames(List<ParamInfo> listOfPairs) {
final ArrayList<String> result = new ArrayList<String>();
- for (MyPair listOfPair : listOfPairs) {
- String name = listOfPair.first;
+ for (ParamInfo listOfPair : listOfPairs) {
+ String name = listOfPair.name;
result.add(name);
}
}
final PsiType[] types = unboxedTypes.toArray(new PsiType[unboxedTypes.size()]);
final String[] names = getMethodArgumentsNames(referenceExpression.getProject(), types);
- final List<MyPair> pairs = swapArgumentsAndTypes(names, types);
+ final List<ParamInfo> infos = swapArgumentsAndTypes(names, types);
settings.setMethod(true);
- settings.setPairs(pairs);
+ settings.setParams(infos);
} else {
settings.setMethod(false);
}
public abstract void removeItemElement(DItemElement element);
- public abstract void replaceDynamicMethodType(String className, String name, List<MyPair> myPairList, String oldType, String newType);
+ public abstract void replaceDynamicMethodType(String className, String name, List<ParamInfo> myPairList, String oldType, String newType);
@NotNull
public abstract DClassElement getOrCreateClassElement(Project project, String className);
removeItemFromTree(element, classElement);
}
- public void replaceDynamicMethodType(String className, String name, List<MyPair> myPairList, String oldType, String newType) {
+ public void replaceDynamicMethodType(String className, String name, List<ParamInfo> myPairList, String oldType, String newType) {
final DMethodElement method = findConcreteDynamicMethod(className, name, QuickfixUtil.getArgumentsTypes(myPairList));
if (method == null) return;
public DItemElement createDynamicElement(DynamicElementSettings settings) {
DItemElement itemElement;
if (settings.isMethod()) {
- itemElement = new DMethodElement(settings.isStatic(), settings.getName(), settings.getType(), settings.getPairs());
+ itemElement = new DMethodElement(settings.isStatic(), settings.getName(), settings.getType(), settings.getParams());
} else {
itemElement = new DPropertyElement(settings.isStatic(), settings.getName(), settings.getType());
}
DynamicManager.getInstance(myProject).replaceDynamicPropertyType(className, name, (String)oldTypeValue, newTypeValue);
} else if (dynamicElement instanceof DMethodElement) {
- final List<MyPair> myPairList = ((DMethodElement)dynamicElement).getPairs();
+ final List<ParamInfo> myPairList = ((DMethodElement)dynamicElement).getPairs();
DynamicManager.getInstance(myProject).replaceDynamicMethodType(className, name, myPairList, (String)oldTypeValue, newTypeValue);
}
}
* User: Dmitry.Krasilschikov
* Date: 29.02.2008
*/
-public class MyPair {
- public String first = null;
- public String second = null;
+public class ParamInfo {
+ public String name = null;
+ public String type = null;
- public MyPair() {}
+ public ParamInfo() {}
- public MyPair(String first, String second) {
- this.first = first;
- this.second = second;
- }
-
- public void setFirst(String first) {
- this.first = first;
- }
-
- public void setSecond(String second) {
- this.second = second;
+ public ParamInfo(String name, String type) {
+ this.name = name;
+ this.type = type;
}
public final int hashCode() {
int hashCode = 0;
- if (first != null) {
- hashCode += first.hashCode();
+ if (name != null) {
+ hashCode += name.hashCode();
}
- if (second != null) {
- hashCode += second.hashCode();
+ if (type != null) {
+ hashCode += type.hashCode();
}
return hashCode;
}
public String toString() {
- return "<" + first + "," + second + ">";
+ return "<" + name + "," + type + ">";
}
}
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.annotator.intentions.QuickfixUtil;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import java.util.*;
@Nullable
public DMethodElement getMethod(String methodName, String[] parametersTypes) {
for (DMethodElement method : myMethods) {
- final List<MyPair> myPairList = method.getPairs();
+ final List<ParamInfo> myPairList = method.getPairs();
if (method.getName().equals(methodName)
&& Arrays.equals(QuickfixUtil.getArgumentsTypes(myPairList), parametersTypes)) return method;
}
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.annotator.intentions.QuickfixUtil;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrDynamicImplicitMethod;
* Date: 12.02.2008
*/
public class DMethodElement extends DItemElement {
- public List<MyPair> myPairs = new ArrayList<MyPair>();
+ public List<ParamInfo> myPairs = new ArrayList<ParamInfo>();
private PsiMethod myImplicitMethod;
@SuppressWarnings("UnusedDeclaration") //for serialization
super(null, null, null);
}
- public DMethodElement(Boolean isStatic, String name, String returnType, List<MyPair> pairs) {
+ public DMethodElement(Boolean isStatic, String name, String returnType, List<ParamInfo> pairs) {
super(isStatic, name, returnType);
myPairs = pairs;
}
- public List<MyPair> getPairs() {
+ public List<ParamInfo> getPairs() {
return myPairs;
}
import org.jetbrains.plugins.groovy.GroovyFileType;
import org.jetbrains.plugins.groovy.annotator.intentions.QuickfixUtil;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.elements.DClassElement;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.elements.DItemElement;
import org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle;
final DItemElement itemElement;
if (mySettings.isMethod()) {
- final List<MyPair> myPairList = mySettings.getPairs();
+ final List<ParamInfo> myPairList = mySettings.getParams();
final String[] argumentsTypes = QuickfixUtil.getArgumentsTypes(myPairList);
itemElement =
myDynamicManager.findConcreteDynamicMethod(mySettings.getContainingClassName(), mySettings.getName(), argumentsTypes);
*/
package org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ui;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import java.util.List;
private String myContainingClassName;
private String myType;
private boolean isMethod;
- private List<MyPair> myPairs;
+ private List<ParamInfo> myParams;
private boolean isStatic;
public void setContainingClassName(String newName) {
isMethod = method;
}
- public List<MyPair> getPairs() {
- return myPairs;
+ public List<ParamInfo> getParams() {
+ return myParams;
}
- public void setPairs(List<MyPair> pairs) {
- myPairs = pairs;
+ public void setParams(List<ParamInfo> pairs) {
+ myParams = pairs;
}
public String getName() {
import com.intellij.util.ui.ListTableModel;
import org.jetbrains.plugins.groovy.GroovyBundle;
import org.jetbrains.plugins.groovy.annotator.intentions.QuickfixUtil;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
GroovyExpectedTypesProvider.calculateTypeConstraints((GrExpression)referenceExpression.getParent()), true);
assert getSettings().isMethod();
- final List<MyPair> pairs = getSettings().getPairs();
+ final List<ParamInfo> pairs = getSettings().getParams();
setupParameterTable(pairs);
setupParameterList(pairs);
setTitle(GroovyBundle.message("add.dynamic.method"));
setUpTypeLabel(GroovyBundle.message("dynamic.method.return.type"));
}
- private void setupParameterTable(final List<MyPair> pairs) {
+ private void setupParameterTable(final List<ParamInfo> pairs) {
MySuggestedNameCellEditor suggestedNameCellEditor = new MySuggestedNameCellEditor(QuickfixUtil.getArgumentsNames(pairs));
myParametersTable.setDefaultEditor(String.class, suggestedNameCellEditor);
String newNameValue = ((MySuggestedNameCellEditor)e.getSource()).getCellEditorValue();
- final MyPair editingPair = pairs.get(editingRow);
- editingPair.setFirst(newNameValue);
+ final ParamInfo editingPair = pairs.get(editingRow);
+ editingPair.name = newNameValue;
}
public void editingCanceled(ChangeEvent e) {
});
}
- private void setupParameterList(List<MyPair> arguments) {
- final ListTableModel<MyPair> dataModel = new ListTableModel<MyPair>(new NameColumnInfo(), new TypeColumnInfo());
+ private void setupParameterList(List<ParamInfo> arguments) {
+ final ListTableModel<ParamInfo> dataModel = new ListTableModel<ParamInfo>(new NameColumnInfo(), new TypeColumnInfo());
dataModel.setItems(arguments);
myParametersTable.setModel(dataModel);
if (arguments.isEmpty()) return;
- String max0 = arguments.get(0).first;
- String max1 = arguments.get(0).second;
- for (MyPair argument : arguments) {
- if (argument.first.length() > max0.length()) max0 = argument.first;
- if (argument.second.length() > max1.length()) max1 = argument.second;
+ String max0 = arguments.get(0).name;
+ String max1 = arguments.get(0).type;
+ for (ParamInfo argument : arguments) {
+ if (argument.name.length() > max0.length()) max0 = argument.name;
+ if (argument.type.length() > max1.length()) max1 = argument.type;
}
final FontMetrics metrics = myParametersTable.getFontMetrics(myParametersTable.getFont());
}
- private class TypeColumnInfo extends ColumnInfo<MyPair, String> {
+ private class TypeColumnInfo extends ColumnInfo<ParamInfo, String> {
public TypeColumnInfo() {
super(GroovyBundle.message("dynamic.name"));
}
- public String valueOf(MyPair pair) {
- return pair.second;
+ public String valueOf(ParamInfo pair) {
+ return pair.type;
}
- public boolean isCellEditable(MyPair stringPsiTypeMyPair) {
+ public boolean isCellEditable(ParamInfo stringPsiTypeMyPair) {
return false;
}
- public void setValue(MyPair pair, String value) {
+ public void setValue(ParamInfo pair, String value) {
PsiType type;
try {
type = GroovyPsiElementFactory.getInstance(myProject).createTypeElement(value).getType();
}
if (type == null) return;
- pair.setSecond(type.getCanonicalText());
+ pair.type =type.getCanonicalText();
}
}
- private static class NameColumnInfo extends ColumnInfo<MyPair, String> {
+ private static class NameColumnInfo extends ColumnInfo<ParamInfo, String> {
public NameColumnInfo() {
super(GroovyBundle.message("dynamic.type"));
}
- public boolean isCellEditable(MyPair myPair) {
+ public boolean isCellEditable(ParamInfo myPair) {
return true;
}
- public String valueOf(MyPair pair) {
- return pair.first;
+ public String valueOf(ParamInfo pair) {
+ return pair.name;
}
}
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicMethodFix;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicPropertyFix;
-import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.MyPair;
+import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ParamInfo;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.elements.DClassElement;
import org.jetbrains.plugins.groovy.annotator.intentions.dynamic.elements.DRootElement;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
final PsiType[] psiTypes = PsiUtil.getArgumentTypes(referenceExpression, false);
final String[] methodArgumentsNames = QuickfixUtil.getMethodArgumentsNames(getProject(), psiTypes);
- final List<MyPair> pairs = QuickfixUtil.swapArgumentsAndTypes(methodArgumentsNames, psiTypes);
+ final List<ParamInfo> pairs = QuickfixUtil.swapArgumentsAndTypes(methodArgumentsNames, psiTypes);
assertNotNull(getDClassElement().getMethod(referenceExpression.getName(), QuickfixUtil.getArgumentsTypes(pairs)));
}