java/java-impl/src/com/intellij/refactoring/changeSignature/ParameterInfoImpl.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * created at Sep 17, 2001
  19  * @author Jeka
  20  */
  21 package com.intellij.refactoring.changeSignature;
  22
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.psi.*;
  25 import com.intellij.refactoring.util.CanonicalTypes;
  26 import com.intellij.util.IncorrectOperationException;
  27 import org.jetbrains.annotations.NonNls;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import java.util.ArrayList;
  31 import java.util.List;
  32
  33 public class ParameterInfoImpl implements ParameterInfo {
  34   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.changeSignature.ParameterInfoImpl");
  35   public final int oldParameterIndex;
  36   boolean useAnySingleVariable;
  37   private String name = "";
  38   private CanonicalTypes.Type myType;
  39
  40   String defaultValue = "";
  41
  42   public ParameterInfoImpl(int oldParameterIndex) {
  43     this.oldParameterIndex = oldParameterIndex;
  44   }
  45
  46   public ParameterInfoImpl(int oldParameterIndex, @NonNls String name, PsiType aType) {
  47     setName(name);
  48     this.oldParameterIndex = oldParameterIndex;
  49     setType(aType);
  50   }
  51
  52   public ParameterInfoImpl(int oldParameterIndex, @NonNls String name, PsiType aType, @NonNls String defaultValue) {
  53     this(oldParameterIndex, name, aType, defaultValue, false);
  54   }
  55
  56   public ParameterInfoImpl(int oldParameterIndex, @NonNls String name, PsiType aType, @NonNls String defaultValue, boolean useAnyVariable) {
  57     this(oldParameterIndex, name, aType);
  58     this.defaultValue = defaultValue;
  59     useAnySingleVariable = useAnyVariable;
  60   }
  61
  62   public int getOldIndex() {
  63     return oldParameterIndex;
  64   }
  65
  66   public void setUseAnySingleVariable(boolean useAnySingleVariable) {
  67     this.useAnySingleVariable = useAnySingleVariable;
  68   }
  69
  70   public void updateFromMethod(PsiMethod method) {
  71     if (getTypeWrapper() != null) return;
  72     final PsiParameter[] parameters = method.getParameterList().getParameters();
  73     LOG.assertTrue(oldParameterIndex >= 0 && oldParameterIndex < parameters.length);
  74     final PsiParameter parameter = parameters[oldParameterIndex];
  75     setName(parameter.getName());
  76     setType(parameter.getType());
  77   }
  78
  79   public boolean equals(Object o) {
  80     if (this == o) return true;
  81     if (!(o instanceof ParameterInfoImpl)) return false;
  82
  83     ParameterInfoImpl parameterInfo = (ParameterInfoImpl) o;
  84
  85     if (oldParameterIndex != parameterInfo.oldParameterIndex) return false;
  86     if (defaultValue != null ? !defaultValue.equals(parameterInfo.defaultValue) : parameterInfo.defaultValue != null) return false;
  87     if (!getName().equals(parameterInfo.getName())) return false;
  88     if (!getTypeText().equals(parameterInfo.getTypeText())) return false;
  89
  90     return true;
  91   }
  92
  93   public int hashCode() {
  94     int result = getName().hashCode();
  95     result = 29 * result + getTypeText().hashCode();
  96     return result;
  97   }
  98
  99   public String getTypeText() {
 100     if (getTypeWrapper() != null) {
 101       return getTypeWrapper().getTypeText();
 102     }
 103     else {
 104       return "";
 105     }
 106   }
 107
 108   public PsiType createType(PsiElement context, final PsiManager manager) throws IncorrectOperationException {
 109     if (getTypeWrapper() != null) {
 110       return getTypeWrapper().getType(context, manager);
 111     } else {
 112       return null;
 113     }
 114   }
 115
 116   public void setType(PsiType type) {
 117     myType = CanonicalTypes.createTypeWrapper(type);
 118   }
 119
 120   public String getName() {
 121     return name;
 122   }
 123
 124   public CanonicalTypes.Type getTypeWrapper() {
 125     return myType;
 126   }
 127
 128   public void setName(String name) {
 129     this.name = name;
 130   }
 131
 132   public boolean isVarargType() {
 133     return getTypeText().endsWith("...");
 134   }
 135
 136   public static ParameterInfoImpl[] fromMethod(PsiMethod method) {
 137     List<ParameterInfoImpl> result = new ArrayList<ParameterInfoImpl>();
 138     final PsiParameter[] parameters = method.getParameterList().getParameters();
 139     for (int i = 0; i < parameters.length; i++) {
 140       PsiParameter parameter = parameters[i];
 141       result.add(new ParameterInfoImpl(i, parameter.getName(), parameter.getType()));
 142     }
 143     return result.toArray(new ParameterInfoImpl[result.size()]);
 144   }
 145
 146   @Nullable
 147   public PsiExpression getValue(final PsiCallExpression expr) throws IncorrectOperationException {
 148     return JavaPsiFacade.getInstance(expr.getProject()).getElementFactory().createExpressionFromText(defaultValue, expr);
 149   }
 150
 151   public boolean isUseAnySingleVariable() {
 152     return useAnySingleVariable;
 153   }
 154
 155   public String getDefaultValue() {
 156     return defaultValue;
 157   }
 158
 159   public void setDefaultValue(final String defaultValue) {
 160     this.defaultValue = defaultValue;
 161   }
 162 }