public TemplateParameterResultItem(CsmTemplateParameter par, int priotity) { super(par, priotity); this.parName = par.getName(); }
private static boolean isExpressionParameter(CsmClassifier cls, CsmSpecializationParameter specParam, int specParamIndex) { if (CsmKindUtilities.isExpressionBasedSpecalizationParameter(specParam)) { return true; } if (CsmKindUtilities.isTemplate(cls)) { List<CsmTemplateParameter> templateParams = ((CsmTemplate) cls).getTemplateParameters(); if (templateParams != null && templateParams.size() > specParamIndex) { CsmTemplateParameter param = templateParams.get(specParamIndex); if (param != null && !param.isTypeBased()) { return true; } } } return false; }
private static boolean hasVariadicParams(CsmTemplate template) { if (template != null && template.getTemplateParameters() != null) { for (CsmTemplateParameter param : template.getTemplateParameters()) { if (param.isVarArgs()) { return true; } } } return false; }
@Override public int compare(CsmTemplateParameter o1, CsmTemplateParameter o2) { if (Objects.equals(o1.getContainingFile(), o2.getContainingFile())) { return o1.getStartOffset() - o2.getStartOffset(); } return 0; } }
/** * Creates digger which will extract template parameter according * to the passed type. * * @param templateParam - template parameter for this digger * @param type - template type which digger uses to get path to the template parameter * @return digger */ public static TypeDigger create(CsmTemplateParameter templateParam, CsmType type) { List<ExtractAction> actions = new ArrayList<ExtractAction>(); CsmType templateType = findTemplateParam(templateParam.getQualifiedName().toString(), templateParam.isVarArgs(), type, actions); if (templateType != null) { return new TypeDigger(actions, templateType); } return null; }
CsmType instType = instParamTypeIter.next(); String instParamText = instParamTextIter.next(); if (specTemplateParam.isTypeBased() && CsmKindUtilities.isTypeBasedSpecalizationParameter(specParam) && instType != null) { CsmType specParamType = ((CsmTypeBasedSpecializationParameter) specParam).getType(); DefaultCalcTemplateTypeStrategy calcStrategy = new DefaultCalcTemplateTypeStrategy(CalcTemplateTypeStrategy.Error.MatchQualsError); CsmType results[] = calcTemplateType(specTemplateParam, specParamType, instType, calcStrategy); if (results != null && results.length > 0) { if (!specTemplateParam.isVarArgs()) { CsmType unfolded = Instantiation.unfoldInstantiatedType(results[0]); return createTypeBasedSpecializationParameter(unfolded, specParam.getScope()); } else if (!specTemplateParam.isTypeBased() && CsmKindUtilities.isTypeBasedSpecalizationParameter(specParam)) { CsmType specParamType = ((CsmTypeBasedSpecializationParameter) specParam).getType(); String specParamText = specParamType != null ? specParamType.getCanonicalText().toString() : null; if (specTemplateParam.getName().toString().equals(specParamText)) { return createExpressionBasedSpecializationParameter( instParamText, } else if (!specTemplateParam.isTypeBased() && CsmKindUtilities.isExpressionBasedSpecalizationParameter(specParam)) { String specParamText = specParam.getText().toString(); if (specTemplateParam.getName().toString().equals(specParamText)) { return createExpressionBasedSpecializationParameter( instParamText, if (specTemplateParam.isVarArgs()) { return createVariadicSpecializationParameter( Collections.<CsmSpecializationParameter>emptyList(), specTemplateParam.getContainingFile(), 0,
public CsmSpecializationParameter resolveTemplateParameter(CsmTemplateParameter templateParameter, MapHierarchy<CsmTemplateParameter, CsmSpecializationParameter> mapping) { if (LOG.isLoggable(Level.FINE)) { LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{templateParameter.getName(), mapping.size()}); if (alreadyResolvedParam.getScope() == templateParameter.getScope()) { if (alreadyResolvedParam.getStartOffset() <= templateParameter.getStartOffset()) {
specParamText = specParam.getText().toString(); for (CsmTemplateParameter specTemplateParam : spec.getTemplateParameters()) { if (!specTemplateParam.isTypeBased()) { if (specTemplateParam.getName().toString().equals(specParamText)) { relatedSpecTemplateParam = specTemplateParam; break; if (relatedSpecTemplateParam != null && !relatedSpecTemplateParam.isTypeBased()) { if(p instanceof ExpressionEvaluator) { val1 = ((ExpressionEvaluator)p).eval( templateParameter.getName().toString(), (CsmInstantiation) cls, CsmKindUtilities.isScope(cls) ? (CsmScope) cls : cls.getScope() } else { val1 = p.eval( templateParameter.getName().toString(), (CsmInstantiation) cls, CsmKindUtilities.isScope(cls) ? (CsmScope) cls : cls.getScope()
if (tplParamIter.hasNext()) { tplParam = tplParamIter.next(); } else if (tplParam == null || !tplParam.isVarArgs()) { if (tplParam.isTypeBased() && canBeFunctionType(paramInst)) { RenderedExpression renderedExpression = renderExpression(paramInst, new ExpressionBuilderImpl.Creator()); type = CsmTypes.createType(renderedExpression.text, context.getContextScope(), new CsmTypes.SequenceDescriptor(
private int calcScore(CsmTemplateParameter param) { CsmSpecializationParameter spec = finalInst.getMapping().get(param); if(CsmKindUtilities.isExpressionBasedSpecalizationParameter(spec)) { if (!((CsmExpressionBasedSpecializationParameter) spec).isDefaultValue()) { return -1; } } return param.getStartOffset(); }
private CsmSpecializationParameter getTemplateParameterDefultValue(CsmTemplate declaration, CsmTemplateParameter param, int index) { CsmSpecializationParameter res = param.getDefaultValue(); if (res != null) { return res; } if (CsmKindUtilities.isClass(declaration)) { CsmClass cls = (CsmClass) declaration; CsmClassForwardDeclaration fdecl; fdecl = findCsmClassForwardDeclaration(cls.getContainingFile(), cls); if (fdecl != null) { List<CsmTemplateParameter> templateParameters = ((CsmTemplate) fdecl).getTemplateParameters(); if (templateParameters.size() > index) { CsmTemplateParameter p = templateParameters.get(index); if (p != null) { res = p.getDefaultValue(); if (res != null) { return res; } } } } } return res; }
private CsmType checkTemplateType(CsmType type, CsmInstantiation inst) { if (CsmKindUtilities.isInstantiation(inst.getTemplateDeclaration())) { type = checkTemplateType(type, (Instantiation)inst.getTemplateDeclaration()); } for (CsmTemplateParameter csmTemplateParameter : inst.getMapping().keySet()) { type = TemplateUtils.checkTemplateType(type, csmTemplateParameter.getScope()); } return type; }
String scopeQualifiedName = CsmKindUtilities.isQualified(scope) ? ((CsmQualifiedNamedElement) scope).getQualifiedName().toString() : decl.getQualifiedName().toString(); if (variableName.equals(param.getQualifiedName().toString()) || (scopeQualifiedName + APTUtils.SCOPE + variableName).equals(param.getQualifiedName().toString())) { CsmSpecializationParameter spec = entry.getValue(); if (CsmKindUtilities.isExpressionBasedSpecalizationParameter(spec)) {
private String getTemplatePrefix(String prefix) { StringBuilder res = new StringBuilder(); if (CsmKindUtilities.isTemplate(parent)) { final CsmTemplate template = (CsmTemplate)parent; List<CsmTemplateParameter> templateParameters = template.getTemplateParameters(); if (templateParameters.size() > 0) { res.append("template<");//NOI18N boolean first = true; for(CsmTemplateParameter param : templateParameters) { if (!first) { res.append(", "); //NOI18N } first = false; res.append(param.getName()); } res.append(">");//NOI18N res.append('\n');//NOI18N } } res.append(prefix); return res.toString(); }
public InstantiationParametersInfoImpl(CsmClassifier classifier, List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> originalParams) { this.classifier = classifier; this.originalParams = originalParams; if (CsmKindUtilities.isTemplate(classifier)) { List<CsmTemplateParameter> templateParams = ((CsmTemplate) classifier).getTemplateParameters(); if (!templateParams.isEmpty() && templateParams.get(templateParams.size() - 1).isVarArgs()) { this.variadic = true; } else { this.variadic = false; } } else { this.variadic = false; } if (hasVariadicParameters(originalParams)) { this.expandedParams = expandVariadicParameters(originalParams); } else { this.expandedParams = this.originalParams; } }
private static CsmType checkTemplateType(CsmType type, List<CsmTemplateParameter> params) { if (params != null && !params.isEmpty()) { CharSequence classifierText = ((TypeImpl)type).getClassifierText(); for (CsmTemplateParameter param : params) { if (CharSequences.comparator().compare(param.getName(), classifierText) == 0) { return new TemplateParameterTypeImpl(type, param); } } } return type; }
CsmType mappedTypes[] = paramsMap.get(param); if (mappedTypes != null && mappedTypes.length > 0) { if (!param.isVarArgs()) { result.add(ip.createTypeBasedSpecializationParameter(mappedTypes[0], getContextScope(context))); } else {
private String getTemplateType() { StringBuilder res = new StringBuilder(); res.append(parent.getName()); if (CsmKindUtilities.isTemplate(parent)) { final CsmTemplate template = (CsmTemplate)parent; List<CsmTemplateParameter> templateParameters = template.getTemplateParameters(); if (templateParameters.size() > 0) { res.append("<");//NOI18N boolean first = true; for(CsmTemplateParameter param : templateParameters) { if (!first) { res.append(", "); //NOI18N } first = false; res.append(param.getName()); } res.append(">");//NOI18N } } return res.toString(); }
if (CsmKindUtilities.isTemplateParameterType(paramType) && paramIndex == funParams.size() - 1 && templateParam.equals(((CsmTemplateParameterType) paramType).getParameter()) && templateParam.isVarArgs()) { List<CsmType> varArgs = new ArrayList<CsmType>(); int argIndex = paramIndex;