public static Collection<CsmMember> getAllMembers(CsmClass typeElement) { // for now returns only current class elements, but in fact needs full hierarchy return typeElement.getMembers(); }
@Override public Collection<CsmMember> getMembers() { Collection<CsmMember> res = new ArrayList<>(); for (CsmMember member : declaration.getMembers()) { res.add(createMember(member)); } return res; }
@Override public Iterator<CsmMember> getClassMembers(CsmClass cls, CsmFilter filter) { if (cls instanceof FilterableMembers){ return ((FilterableMembers)cls).getMembers(filter); } return cls.getMembers().iterator(); }
private Collection<? extends CsmObject> getRenamingClassObjects(CsmClass clazz) { Collection<CsmObject> out = new ArrayList<CsmObject>(5); if (clazz != null) { out.add(clazz); for (CsmMember member : clazz.getMembers()) { if (CsmKindUtilities.isConstructor(member)) { out.add(member); } else if (CsmKindUtilities.isDestructor(member)) { out.add(member); } } } return out; }
private static CsmOffsetableDeclaration findInnerDeclaration(CsmOffsetableDeclaration outDecl, int offset) { Iterator it = null; CsmOffsetableDeclaration innerDecl = null; if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass)outDecl; it = cl.getMembers().iterator(); } if (it != null) { while (it.hasNext()) { CsmOffsetableDeclaration decl = (CsmOffsetableDeclaration) it.next(); if (isInObject(decl, offset)) { innerDecl = findInnerDeclaration(decl, offset); innerDecl = innerDecl != null ? innerDecl : decl; break; } } } return innerDecl; }
private void visitClasses(Set<CsmClass> classes, Collection<? extends CsmOffsetableDeclaration> decls, final int caretOffset) { for(CsmOffsetableDeclaration decl : decls) { if (CsmKindUtilities.isNamespaceDefinition(decl)) { visitClasses(classes, ((CsmNamespaceDefinition)decl).getDeclarations(), caretOffset); } else if (CsmKindUtilities.isClass(decl)) { visitClasses(classes, ((CsmClass)decl).getMembers(), caretOffset); classes.add((CsmClass)decl); } } }
private void initClass(CsmClass cls, java.util.Map<PersistentKey, SortedName> res){ for(CsmMember member : cls.getMembers()) { PersistentKey key = PersistentKey.createKey(member); if (key != null) { res.put(key, getSortedName(member)); } } for (CsmFriend friend : cls.getFriends()){ PersistentKey key = PersistentKey.createKey(friend); if (key != null) { res.put(key, getSortedName(friend)); } } }
public Collection<CsmMember> _getMembers() { Collection<CsmMember> members = new ArrayList<>(); members.addAll(super.getMembers()); ClassImpl base = findBaseClassImplInProject(); if(base != null && base != this) { CsmInstantiationProvider p = CsmInstantiationProvider.getDefault(); if(p instanceof InstantiationProviderImpl) { CsmObject baseInst = ((InstantiationProviderImpl)p).instantiate(base, this.getSpecializationParameters(), false); if(CsmKindUtilities.isClass(baseInst)) { members.addAll(((CsmClass)baseInst).getMembers()); } } } return members; }
public static CsmMethod findMethod(CsmClass clazz, String name, Collection<? extends CsmVariable> params, boolean includeSupertypes) { if (name == null || name.length() == 0) { return null; } CsmClass c = clazz; // while (true) { for (CsmMember elm : c.getMembers()) { if (CsmKindUtilities.isMethod(elm)) { CsmMethod m = (CsmMethod) elm; if (name.contentEquals(m.getName()) && compareParams(params, m.getParameters()) /*&& isAccessible(clazz, m)*/) { return m; } } } // // TypeMirror superType = c.getSuperclass(); // if (!includeSupertypes || superType.getKind() == TypeKind.NONE) { return null; // } // c = (CsmClass) ((DeclaredType) superType).asElement(); // } }
private static CsmDeclaration findInnerDeclaration(CsmDeclaration outDecl, int offset) { assert (isInObject(outDecl, offset)) : "must be in outDecl object!"; Iterator<? extends CsmDeclaration> it = null; if (CsmKindUtilities.isNamespace(outDecl)) { CsmNamespace ns = (CsmNamespace)outDecl; it = ns.getDeclarations().iterator(); } else if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass)outDecl; it = cl.getMembers().iterator(); } else if (CsmKindUtilities.isEnum(outDecl)) { CsmEnum en = (CsmEnum)outDecl; it = en.getEnumerators().iterator(); } return findInnerDeclaration(it, offset); }
public static void scanForFieldsAndConstructors(final CsmClass clsPath, final Set<CsmField> shouldBeInitializedFields, final Set<CsmField> mayBeIninitializedFields, final Set<CsmField> cannotBeInitializedFields, final List<CsmConstructor> constructors) { for (CsmMember member : clsPath.getMembers()) { if (CsmKindUtilities.isField(member)) { CsmField field = (CsmField) member; if (field.isStatic()) { continue; } CsmType type = field.getType(); if (type.getArrayDepth() > 0) { cannotBeInitializedFields.add(field); continue; } if (type.isConst() || type.isReference()) { shouldBeInitializedFields.add(field); continue; } mayBeIninitializedFields.add(field); } else if (CsmKindUtilities.isConstructor(member)) { constructors.add((CsmConstructor)member); } } } //
private void getVirtualMethods(Set<CsmMethod> res, CsmClass cls, Set<AntiLoopElement> antiLoop) { AntiLoopElement element = new AntiLoopElement(cls); if (antiLoop.contains(element)) { return; } antiLoop.add(element); Collection<CsmInheritance> baseClasses = cls.getBaseClasses(); for(CsmInheritance inh : baseClasses) { element = new AntiLoopElement(inh); if (antiLoop.contains(element)) { continue; } antiLoop.add(element); CsmClassifier classifier = inh.getClassifier(); if (CsmKindUtilities.isClass(classifier)/* && !CsmKindUtilities.isInstantiation(classifier)*/) { CsmClass c = (CsmClass) classifier; getVirtualMethods(res, c, antiLoop); for(CsmMember member : c.getMembers()) { if(CsmKindUtilities.isMethod(member)) { if (CsmVirtualInfoQuery.getDefault().isVirtual((CsmMethod) member)) { res.add((CsmMethod) member); } } } } } }
private static void visitDeclarations(Collection<? extends CsmOffsetableDeclaration> decls, StatisticsParameters params, XRefResultSet<XRefEntry> bag, PrintWriter printOut, OutputWriter printErr, AtomicBoolean canceled) { for (CsmOffsetableDeclaration decl : decls) { if (CsmKindUtilities.isFunctionDefinition(decl)) { handleFunctionDefinition((CsmFunctionDefinition) decl, params, bag, printOut, printErr); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { visitDeclarations(((CsmNamespaceDefinition) decl).getDeclarations(), params, bag, printOut, printErr, canceled); } else if (CsmKindUtilities.isClass(decl)) { visitDeclarations(((CsmClass) decl).getMembers(), params, bag, printOut, printErr, canceled); } if (canceled.get()) { break; } } }
private static CsmClass resolveInitializerContext(List<Token<TokenId>> identSequence, CsmClass context) { for (Token<TokenId> ident : identSequence) { CsmClassifier classifier = null; if (ident.text() != null) { String fieldName = ident.text().toString(); for (CsmMember csmMember : context.getMembers()) { if (CsmKindUtilities.isField(csmMember) && fieldName.equals(csmMember.getName().toString())) { CsmType fieldType = ((CsmField)csmMember).getType(); if (fieldType != null) { classifier = CsmBaseUtilities.getOriginalClassifier(fieldType.getClassifier(), fieldType.getContainingFile()); } break; } } } if (CsmKindUtilities.isClass(classifier)) { context = (CsmClass) classifier; } if (classifier == null) { context = null; // error happened break; } } return context; }
private static void addDeclarationAndNested(Collection<FileElement> toAdd, CsmOffsetableDeclaration outDecl) { // TODO: what about function return value? // TODO: what about function params? // TODO: what about const/virtual attributes? // TODO: what about static? CharAndCharSequence cs = new CharAndCharSequence(outDecl.getQualifiedName(), Utils.getCsmDeclarationKindkey(outDecl.getKind())); FileElement fe = new FileElement(outDecl.getStartOffset(), cs); toAdd.add(fe); Iterator<? extends CsmOffsetableDeclaration> it = null; if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass) outDecl; it = cl.getMembers().iterator(); for (CsmInheritance inh : cl.getBaseClasses()) { CharAndCharSequence csi = new CharAndCharSequence(inh.getAncestorType().getClassifierText(), Utils.getCsmInheritanceKindKey(inh)); toAdd.add(new FileElement(inh.getStartOffset(), csi)); } } else if (CsmKindUtilities.isEnum(outDecl)) { CsmEnum en = (CsmEnum) outDecl; it = en.getEnumerators().iterator(); } if (it != null) { while (it.hasNext()) { CsmOffsetableDeclaration decl = (CsmOffsetableDeclaration) it.next(); addDeclarationAndNested(toAdd, decl); } } }
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); } } } }
private StatementResult findExpressionStatement(Collection<? extends CsmOffsetableDeclaration> decls, int selectionStart, int selectionEnd, Document doc, final AtomicBoolean canceled) { for(CsmOffsetableDeclaration decl : decls) { if (canceled.get()) { return null; } if (decl.getStartOffset() < selectionStart && selectionEnd < decl.getEndOffset()) { if (CsmKindUtilities.isFunctionDefinition(decl)) { CsmFunctionDefinition def = (CsmFunctionDefinition) decl; return findExpressionStatementInBody(def.getBody(), selectionStart, selectionEnd, doc, canceled); } else if (CsmKindUtilities.isNamespaceDefinition(decl)) { CsmNamespaceDefinition def = (CsmNamespaceDefinition) decl; return findExpressionStatement(def.getDeclarations(), selectionStart, selectionEnd, doc, canceled); } else if (CsmKindUtilities.isClass(decl)) { CsmClass cls = (CsmClass) decl; return findExpressionStatement(cls.getMembers(), selectionStart, selectionEnd, doc, canceled); } } } return null; }
for (CsmMember member : cls.getMembers()) { checkCancelled(); if (matcher.accept(member.getName().toString())) {
private static boolean findInner(CsmClass clazz, int offset, CsmContext context) { CsmContextUtilities.updateContext(clazz, offset, context); CsmMember member = CsmOffsetUtilities.findObject(clazz.getMembers(), context, offset); if (!CsmOffsetUtilities.sameOffsets(clazz, member)) { if (CsmKindUtilities.isClass(member)) { findInner((CsmClass)member, offset, context); } else if (CsmKindUtilities.isFunctionDefinition(member)) { CsmContextUtilities.updateContext(member, offset, context); CsmCompoundStatement body = ((CsmFunctionDefinition)member).getBody(); if (!CsmOffsetUtilities.sameOffsets(member, body)) { findInnerObject(body, offset, context); } } } return true; }
CsmClass cls = (CsmClass) parent; CsmOffsetableDeclaration best = null; for(CsmMember decl : cls.getMembers()){ if (decl.getStartOffset() <= position && position <= decl.getEndOffset()) { return getInternalDeclaration(decl, position);