@Override public boolean check(CsmType value) { CsmClassifier cls = value.getClassifier(); return CsmKindUtilities.isTemplate(cls); }
private CsmClassifier tryInstantiateClassifier(CsmClassifier template, CsmCompletionExpression exp) { if (exp != null && CsmKindUtilities.isTemplate(template)) { CsmObject inst = CompletionSupport.createInstantiation(this, (CsmTemplate) template, exp, Collections.<CsmType>emptyList()); if (CsmKindUtilities.isClassifier(inst)) { template = (CsmClassifier) inst; } } return template; }
protected String getName() { return CsmKindUtilities.isTemplate(cls) ? ((CsmTemplate) cls).getDisplayName().toString() : cls.getName().toString(); }
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(); }
private boolean isTemplateScope(CsmClass cls) { while (!CsmKindUtilities.isTemplate(cls)) { if (!CsmKindUtilities.isClassMember(cls)) { return false; } cls = ((CsmMember) cls).getContainingClass(); } return true; } }
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(); }
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; }
/** * Checks if template conversions are not conflicting * @param function * @param conversions * @return true if there are no conflicts */ private static boolean checkTemplateAcceptable(CsmFunctional function, List<Conversion> conversions) { if (CsmKindUtilities.isTemplate(function)) { Map<String, String> map = new HashMap<String, String>(); for (Conversion conversion : conversions) { if (ConversionCategory.Template.equals(conversion.category)) { String paramCanonicalText = conversion.to.getCanonicalText().toString(); if (map.containsKey(paramCanonicalText)) { String valueText = conversion.from.getCanonicalText().toString(); if (!valueText.equals(map.get(paramCanonicalText))) { return false; } } else { map.put(paramCanonicalText, conversion.from.getCanonicalText().toString()); } } } } return true; }
protected CharSequence toStringName() { CharSequence name; if (CsmKindUtilities.isTemplate(this)) { name = ((CsmTemplate)this).getDisplayName(); } else { name = getName(); } if (this instanceof RawNamable) { StringBuilder out = new StringBuilder(name); out.append('('); boolean first = true; for (CharSequence part : ((RawNamable)this).getRawName()) { if (first) { first = false; } else { out.append("::"); //NOI18N } out.append(part); } out.append(')'); name = out; } return name; }
private static void addTemplate(CsmFunction item, CsmClass parent, StringBuilder sb) { if (CsmKindUtilities.isTemplate(parent)) { final CsmTemplate template = (CsmTemplate)parent; List<CsmTemplateParameter> templateParameters = template.getTemplateParameters(); if (CsmKindUtilities.isTemplate(item)) { final CsmTemplate template = (CsmTemplate)item; List<CsmTemplateParameter> templateParameters = template.getTemplateParameters();
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; } }
static CsmObject createInstantiation(Context context, CsmTemplate template, CsmCompletionExpression exp, List<CsmType> typeList) { if (exp != null || !typeList.isEmpty() || context.getContextInstantiations() != null) { CsmInstantiationProvider ip = CsmInstantiationProvider.getDefault(); List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>(); params.addAll(collectInstantiationParameters(context, template, ip, exp)); if (CsmKindUtilities.isFunction(template)) { params.addAll(collectInstantiationParameters(context, ip, (CsmFunction)template, params.size(), typeList)); } CsmObject instantiation = ip.instantiate(template, params); if (CsmKindUtilities.isTemplate(instantiation)) { List<CsmInstantiation> contextInstantiations = context.getContextInstantiations(); if (contextInstantiations != null && !contextInstantiations.isEmpty()) { ListIterator<CsmInstantiation> iter = contextInstantiations.listIterator(contextInstantiations.size()); while (iter.hasPrevious()) { instantiation = ip.instantiate((CsmTemplate) instantiation, iter.previous()); } } } return instantiation; } return null; }
private void getTemplateParameters(CsmTemplate template, String strPrefix, boolean match, Collection<CsmTemplateParameter> out) { for (CsmTemplateParameter elem : template.getTemplateParameters()) { if (CsmSortUtilities.matchName(elem.getName(), strPrefix, match, caseSensitive)) { out.add(elem); } if (CsmKindUtilities.isTemplate(elem)) { getTemplateParameters((CsmTemplate) elem, strPrefix, match, out); } } }
@Override public CsmClass getCsmClass() { if (csmClass == null) { CsmClass declClassifier = declaration.getCsmClass(); if (CsmKindUtilities.isTemplate(declClassifier)) { csmClass = (CsmClass)Instantiation.create((CsmTemplate)declClassifier, getMapping()); } else { csmClass = declClassifier; } } return csmClass; } }
public CsmClass _getContainingClass() { CsmClass containingClass = declaration.getContainingClass(); if(CsmKindUtilities.isTemplate(containingClass)) { CsmInstantiationProvider p = CsmInstantiationProvider.getDefault(); if (p instanceof InstantiationProviderImpl) { CsmObject inst = ((InstantiationProviderImpl) p).instantiate((CsmTemplate)containingClass, instantiation); if (inst instanceof CsmClass) { return (CsmClass) inst; } } } return containingClass; }
@Override public CsmEnum getCsmEnum() { if (csmEnum == null) { CsmEnum declClassifier = declaration.getCsmEnum(); if (CsmKindUtilities.isTemplate(declClassifier)) { csmEnum = (CsmEnum) Instantiation.create((CsmTemplate) declClassifier, getMapping()); } else { csmEnum = declClassifier; } } return csmEnum; } }
static List<CsmSpecializationParameter> collectInstantiationParameters(Context context, CsmInstantiationProvider ip, CsmFunction function, int explicitelyMappedSize, List<CsmType> typeList) { if (CsmKindUtilities.isTemplate(function)) { List<CsmSpecializationParameter> result = new ArrayList<CsmSpecializationParameter>();
private void computeAnnotations(Collection<? extends CsmOffsetableDeclaration> toProcess, Collection<BaseAnnotation> toAdd) { for (CsmOffsetableDeclaration decl : toProcess) { if (canceled.get()) { return; } if (this.csmFile.equals(decl.getContainingFile())) { if (CsmKindUtilities.isFunction(decl)) { computeAnnotation((CsmFunction) decl, toAdd); } else if (CsmKindUtilities.isClass(decl)) { if (CsmKindUtilities.isTemplate(decl)) { if (((CsmTemplate)decl).isExplicitSpecialization()) { continue; } } computeAnnotation((CsmClass) decl, toAdd); computeAnnotations(((CsmClass) decl).getMembers(), toAdd); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { computeAnnotations(((CsmNamespaceDefinition) decl).getDeclarations(), toAdd); } } } }
if ((kind != CsmDeclaration.Kind.STRUCT && kind != CsmDeclaration.Kind.UNION) || CsmKindUtilities.isTemplate(decl)) { CsmClass cls = (CsmClass) scope; kind = cls.getKind(); if ((kind != CsmDeclaration.Kind.STRUCT && kind != CsmDeclaration.Kind.UNION) || CsmKindUtilities.isTemplate(decl)) {
static CsmType extractFunctionType(Context context, Collection<? extends CsmFunctional> mtdList, CsmCompletionExpression genericNameExp, List<CsmType> typeList) { CsmType out = null; if (mtdList.isEmpty()) { return null; } for (CsmFunctional fun : mtdList) { CsmObject entity = fun; if (CsmKindUtilities.isConstructor(entity)) { entity = ((CsmConstructor) entity).getContainingClass(); } if (CsmKindUtilities.isTemplate(entity)) { CsmObject inst = createInstantiation(context, (CsmTemplate) entity, genericNameExp, typeList); if (CsmKindUtilities.isFunction(inst) || CsmKindUtilities.isClassifier(inst)) { entity = inst; } } if (CsmKindUtilities.isFunctional(entity)) { out = ((CsmFunctional) entity).getReturnType(); } else if (CsmKindUtilities.isClassifier(entity)) { out = CsmCompletion.createType((CsmClassifier) entity, 0, 0, 0, false); } if (out != null) { break; } } return out; }