Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (C) 2007-2010 Júlio Vilmar Gesser.
* Copyright (C) 2011, 2013-2021 The JavaParser Team.
*
* This file is part of JavaParser.
*
* JavaParser can be used either under the terms of
* a) the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* b) the terms of the Apache License
*
* You should have received a copy of both licenses in LICENCE.LGPL and
* LICENCE.APACHE. Please refer to those files for details.
*
* JavaParser 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 Lesser General Public License for more details.
*/
package com.github.javaparser.resolution;
import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
import com.github.javaparser.resolution.types.ResolvedType;
import com.github.javaparser.resolution.types.parametrization.ResolvedTypeParametersMap;
import com.github.javaparser.resolution.types.parametrization.ResolvedTypeParametrized;
import java.util.*;
/**
* This is basically a MethodDeclaration with some TypeParameters defined.
* The defined TypeParameters can comes from the Method itself or from the surrounding types.
*
* @author Federico Tomassetti
*/
public class MethodUsage implements ResolvedTypeParametrized {
private ResolvedMethodDeclaration declaration;
private List paramTypes = new ArrayList<>();
private List exceptionTypes = new ArrayList<>();
private ResolvedType returnType;
private ResolvedTypeParametersMap typeParametersMap;
public MethodUsage(ResolvedMethodDeclaration declaration) {
this.typeParametersMap = ResolvedTypeParametersMap.empty();
this.declaration = declaration;
for (int i = 0; i < declaration.getNumberOfParams(); i++) {
paramTypes.add(declaration.getParam(i).getType());
}
for (int i = 0; i < declaration.getNumberOfSpecifiedExceptions(); i++) {
exceptionTypes.add(declaration.getSpecifiedException(i));
}
returnType = declaration.getReturnType();
}
public MethodUsage(ResolvedMethodDeclaration declaration,
List paramTypes, ResolvedType returnType) {
this(declaration, paramTypes, returnType, declaration.getSpecifiedExceptions(),
ResolvedTypeParametersMap.empty());
}
public MethodUsage(ResolvedMethodDeclaration declaration, List paramTypes, ResolvedType returnType,
List exceptionTypes) {
this(declaration, paramTypes, returnType, exceptionTypes, ResolvedTypeParametersMap.empty());
}
private MethodUsage(ResolvedMethodDeclaration declaration, List paramTypes, ResolvedType returnType,
List exceptionTypes, ResolvedTypeParametersMap typeParametersMap) {
this.declaration = declaration;
this.paramTypes = paramTypes;
this.returnType = returnType;
this.exceptionTypes = exceptionTypes;
this.typeParametersMap = typeParametersMap;
}
@Override
public String toString() {
return "MethodUsage{" +
"declaration=" + declaration +
", paramTypes=" + paramTypes +
'}';
}
public ResolvedMethodDeclaration getDeclaration() {
return declaration;
}
public String getName() {
return declaration.getName();
}
public ResolvedReferenceTypeDeclaration declaringType() {
return declaration.declaringType();
}
public ResolvedType returnType() {
return returnType;
}
public List getParamTypes() {
return paramTypes;
}
public MethodUsage replaceParamType(int i, ResolvedType replaced) {
if (i < 0 || i >= getNoParams()) {
throw new IllegalArgumentException();
}
if (paramTypes.get(i) == replaced) {
return this;
}
List newParams = new LinkedList<>(paramTypes);
newParams.set(i, replaced);
return new MethodUsage(declaration, newParams, returnType, exceptionTypes, typeParametersMap);
}
public MethodUsage replaceExceptionType(int i, ResolvedType replaced) {
if (i < 0 || i >= exceptionTypes.size()) {
throw new IllegalArgumentException();
}
if (exceptionTypes.get(i) == replaced) {
return this;
}
List newTypes = new LinkedList<>(exceptionTypes);
newTypes.set(i, replaced);
return new MethodUsage(declaration, paramTypes, returnType, newTypes, typeParametersMap);
}
public MethodUsage replaceReturnType(ResolvedType returnType) {
if (returnType == this.returnType) {
return this;
} else {
return new MethodUsage(declaration, paramTypes, returnType, exceptionTypes, typeParametersMap);
}
}
/**
* Return the number of formal arguments accepted by this method.
*/
public int getNoParams() {
return paramTypes.size();
}
/**
* Return the type of the formal argument at the given position.
*/
public ResolvedType getParamType(int i) {
return paramTypes.get(i);
}
public MethodUsage replaceTypeParameter(ResolvedTypeParameterDeclaration typeParameter, ResolvedType type) {
if (type == null) {
throw new IllegalArgumentException();
}
// TODO if the method declaration has a type param with that name ignore this call
MethodUsage res = new MethodUsage(declaration, paramTypes, returnType, exceptionTypes,
typeParametersMap.toBuilder().setValue(typeParameter, type).build());
Map inferredTypes = new HashMap<>();
for (int i = 0; i < paramTypes.size(); i++) {
ResolvedType originalParamType = paramTypes.get(i);
ResolvedType newParamType = originalParamType.replaceTypeVariables(typeParameter, type, inferredTypes);
res = res.replaceParamType(i, newParamType);
}
for (int i = 0; i < exceptionTypes.size(); i++) {
ResolvedType originalType = exceptionTypes.get(i);
ResolvedType newType = originalType.replaceTypeVariables(typeParameter, type, inferredTypes);
res = res.replaceExceptionType(i, newType);
}
ResolvedType oldReturnType = res.returnType;
ResolvedType newReturnType = oldReturnType.replaceTypeVariables(typeParameter, type, inferredTypes);
res = res.replaceReturnType(newReturnType);
return res;
}
@Override
public ResolvedTypeParametersMap typeParametersMap() {
return typeParametersMap;
}
/**
* The qualified signature of the method. It is composed by the qualified name of the declaring type
* followed by the signature of the method.
*/
public String getQualifiedSignature() {
return getDeclaration().declaringType().getQualifiedName() + "." + getSignature();
}
/**
* The signature of the method.
*/
public String getSignature() {
StringBuilder sb = new StringBuilder();
sb.append(getName());
sb.append("(");
for (int i = 0; i < getNoParams(); i++) {
if (i != 0) {
sb.append(", ");
}
ResolvedType type = getParamType(i);
if (type.isArray() && getDeclaration().getParam(i).isVariadic()) {
sb.append(type.asArrayType().getComponentType().describe()).append("...");
} else {
sb.append(type.describe());
}
}
sb.append(")");
return sb.toString();
}
public List exceptionTypes() {
return exceptionTypes;
}
}
