org.walkmod.javalang.compiler.reflection.AbstractCompatibleArgsPredicate Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javalang-compiler Show documentation
Library of compiler components to processs Java code.
There is a newer version: 2.3.10
/*
 * Copyright (C) 2015 Raquel Pau and Albert Coroleu.
 * 
 * Walkmod is free software: you can redistribute it and/or modify it under the terms of 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.
 * 
 * Walkmod 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.
 * 
 * You should have received a copy of the GNU Lesser General Public License along with Walkmod. If
 * not, see .
 */
package org.walkmod.javalang.compiler.reflection;

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;

import org.walkmod.javalang.compiler.symbols.SymbolType;

public abstract class AbstractCompatibleArgsPredicate {

    private SymbolType[] typeArgs;

    private Map typeMapping;

    private Map methodArgsMapping;

    private Type[] genericParameterTypes;

    private boolean isVarAgs;

    private int paramsCount;

    private SymbolType[] inferredMethodArgs;

    public AbstractCompatibleArgsPredicate() {}

    public AbstractCompatibleArgsPredicate(SymbolType[] typeArgs) {
        this.typeArgs = typeArgs;
    }

    public SymbolType[] getInferredMethodArgs() {
        return inferredMethodArgs;
    }

    public boolean filter() throws Exception {
        int numParams = typeArgs == null ? 0 : typeArgs.length;
        SymbolType lastVariableTypeArg = null;
        SymbolType[] newTypeArgs = typeArgs;
        boolean isCompatible = true;
        if ((paramsCount == numParams) || (isVarAgs && numParams >= (paramsCount - 1))) {

            // if I enter again, is that the previous method is not valid
            if (methodArgsMapping != null && !methodArgsMapping.isEmpty() && typeMapping != null) {
                // we restore the typeMapping values, to the original ones.
                for (String key : methodArgsMapping.keySet()) {
                    typeMapping.remove(key);
                }
            }
            methodArgsMapping = new HashMap();
            inferredMethodArgs = new SymbolType[genericParameterTypes.length];

            for (int i = 0; i < genericParameterTypes.length && i < numParams; i++) {
                inferredMethodArgs[i] =
                        SymbolType.valueOf(genericParameterTypes[i], typeArgs[i], methodArgsMapping, typeMapping);

            }
            if (isVarAgs) {

                if (paramsCount <= numParams) {
                    if (numParams == (paramsCount - 1)) {
                        lastVariableTypeArg = SymbolType.valueOf(genericParameterTypes[paramsCount - 1], typeMapping);
                    } else {
                        lastVariableTypeArg = inferredMethodArgs[inferredMethodArgs.length - 1];
                    }

                    if (paramsCount < typeArgs.length) {
                        // checking if the list of received type args from the
                        // dynamic argument position are compatibles with the array type.
                        SymbolType lastParam = inferredMethodArgs[paramsCount - 1].clone();
                        lastParam.setArrayCount(lastParam.getArrayCount() - 1);
                        for (int i = paramsCount - 1; i < typeArgs.length && isCompatible; i++) {
                            isCompatible = lastParam.isCompatible(typeArgs[i]);
                        }
                    }
                    if (isCompatible) {

                        numParams = paramsCount;

                        // changing the last argument to an array
                        newTypeArgs = new SymbolType[paramsCount];

                        for (int i = 0; i < newTypeArgs.length - 1 && i < typeArgs.length; i++) {
                            newTypeArgs[i] = typeArgs[i];
                        }

                        if (inferredMethodArgs.length == numParams && newTypeArgs[numParams - 1] != null) {
                            if (inferredMethodArgs[numParams - 1].getArrayCount() != newTypeArgs[numParams - 1]
                                    .getArrayCount()) {
                                newTypeArgs[newTypeArgs.length - 1] = lastVariableTypeArg.clone();
                                newTypeArgs[newTypeArgs.length - 1]
                                        .setArrayCount(newTypeArgs[newTypeArgs.length - 1].getArrayCount() - 1);
                            }
                        }

                    }

                } else {
                    if (inferredMethodArgs.length > 0 && inferredMethodArgs[inferredMethodArgs.length - 1] != null) {
                        inferredMethodArgs[inferredMethodArgs.length - 1]
                                .setArrayCount(inferredMethodArgs[inferredMethodArgs.length - 1].getArrayCount() - 1);
                    }
                }
            }

            for (int i = 0; i < numParams && isCompatible; i++) {

                isCompatible = newTypeArgs[i] == null || inferredMethodArgs[i].isCompatible(newTypeArgs[i]);

            }

            if (isCompatible && lastVariableTypeArg != null) {

                for (int j = numParams; j < newTypeArgs.length && isCompatible; j++) {
                    isCompatible = lastVariableTypeArg.isCompatible(newTypeArgs[j]);

                }

            }
        } else {
            isCompatible = false;
        }
        if (isCompatible && methodArgsMapping != null && typeMapping != null) {
            typeMapping.putAll(methodArgsMapping);
        }

        return isCompatible;
    }

    public void setTypeArgs(SymbolType[] typeArgs) {
        this.typeArgs = typeArgs;
    }

    public SymbolType[] getTypeArgs() {
        return typeArgs;
    }

    public void setTypeMapping(Map typeMapping) {
        this.typeMapping = typeMapping;
    }

    public Map getTypeMapping() {
        return typeMapping;
    }

    public Map getMethodArgsMapping() {
        return methodArgsMapping;
    }

    public void setMethodArgsMapping(Map methodArgsMapping) {
        this.methodArgsMapping = methodArgsMapping;
    }

    public Type[] getGenericParameterTypes() {
        return genericParameterTypes;
    }

    public void setGenericParameterTypes(Type[] methodParameterTypes) {
        this.genericParameterTypes = methodParameterTypes;
    }

    public boolean isVarAgs() {
        return isVarAgs;
    }

    public void setVarAgs(boolean isVarAgs) {
        this.isVarAgs = isVarAgs;
    }

    public int getParameterTypesLenght() {
        return paramsCount;
    }

    public void setParameterTypesLenght(int paramsCount) {
        this.paramsCount = paramsCount;
    }

}