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 HierarchyNode(CsmClass element, Children children, HierarchyModel model, boolean recursion) { super(children); if (recursion) { setName(element.getName()+" "+getString("CTL_Recuesion")); // NOI18N } else { setName(element.getName().toString()); } object = element; this.model = model; uin = object.getUniqueName(); project = object.getContainingFile().getProject(); }
public static boolean isInClassScope(final CsmClass clazz, final int offset) { return isInObject(clazz, offset) && clazz.getLeftBracketOffset() < offset && offset < clazz.getEndOffset(); }
/** * Returns the full name of the class: * for a top-level class it's just a class name, * for a nested class, it contain outer class name * (but in any case without a namespace) */ public static String getClassFullName(CsmClass cls) { StringBuilder sb = new StringBuilder(cls.getName()); CsmScope scope = cls.getScope(); while( scope != null && CsmKindUtilities.isClass(scope) ) { CsmClass outer = (CsmClass)scope; sb.insert(0, "::"); // NOI18N sb.insert(0, (outer).getName()); scope = outer.getScope(); } return sb.toString(); }
classesAskedForMembers.add(clazz); if (inspectOuterClasses) { CsmScope outerScope = clazz.getScope(); while (CsmKindUtilities.isClass(outerScope)) { if (!handledClasses.contains((CsmClass) outerScope)) { classesAskedForMembers.add((CsmClass) outerScope); outerScope = ((CsmClass) outerScope).getScope(); CsmProject classProject = clazz.getContainingFile().getProject(); if (classProject != null) { CharSequence[] nameParts = splitQualifiedName(clazz.getQualifiedName().toString()); if (nameParts.length > 1) { StringBuilder className = new StringBuilder(""); // NOI18N CsmClass innerClass = (CsmClass) member; if (innerClass.getEnclosingVariables().isEmpty()) { Map<CharSequence, CsmMember> set = getClassMembers(innerClass, contextDeclaration, kinds, strPrefix, staticOnly, match, handledClasses, CsmVisibility.PUBLIC, INIT_INHERITANCE_LEVEL, inspectParentClasses, inspectOuterClasses, returnBaseClasses, returnUnnamedMembers); for (Iterator<CsmInheritance> it2 = csmClass.getBaseClasses().iterator(); it2.hasNext();) { CsmInheritance inherit = it2.next(); CsmClass baseClass = CsmInheritanceUtilities.getCsmClass(inherit); if (baseClass != null) { if (returnBaseClasses) { CharSequence baseClsName = baseClass.getName(); if (isKindOf(baseClass.getKind(), kinds) && (matchName(baseClsName, strPrefix, match))) {
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); } } } } } }
public static Collection<CsmMember> getAllMembers(CsmClass typeElement) { // for now returns only current class elements, but in fact needs full hierarchy return typeElement.getMembers(); }
for (Iterator<CsmInheritance> it2 = csmClass.getBaseClasses().iterator(); it2.hasNext();) { CsmInheritance inherit = it2.next(); CsmClass baseClass = CsmInheritanceUtilities.getCsmClass(inherit); Map<CharSequence, CsmClass> baseRes = getBaseClasses(baseClass, contextDeclaration, strPrefix, match, handledClasses, nextMinVisibility, nextInheritanceLevel); if (matchName(baseClass.getName(), strPrefix, match)) { baseRes.put(baseClass.getQualifiedName(), baseClass);
private static boolean isNestedClass(CsmClass inner, CsmClass outer) { return inner != null && outer != null && CharSequenceUtilities.startsWith(inner.getQualifiedName(),outer.getQualifiedName()); }
if (decl.getStartOffset() <= caretOffset && caretOffset <= decl.getEndOffset()) { CsmClass cls = (CsmClass) decl; int leftBracketOffset = cls.getLeftBracketOffset(); if (leftBracketOffset >= caretOffset) { return null; List<CsmMember> members = new ArrayList<CsmMember>(cls.getMembers()); for(int i = 0; i < members.size(); i++) { CsmMember member = members.get(i);
/** * Returns the namespace the given class belongs * (even if it's a nested class) */ public static CsmNamespace getClassNamespace(CsmClass cls) { CsmScope scope = cls.getScope(); while( scope != null && CsmKindUtilities.isClass(scope) ) { CsmClass outer = (CsmClass)scope; scope = outer.getScope(); } return CsmKindUtilities.isNamespace(scope) ? (CsmNamespace) scope : null; }
private void init(final CsmClass cls){ final CharSequence old = name; name = CsmKindUtilities.isTemplate(cls) ? ((CsmTemplate)cls).getDisplayName() : cls.getName(); final CharSequence oldQ = qname; if (CsmKindUtilities.isTemplate(cls)) { qname = cls.getQualifiedName()+"<>"; // NOI18N } else { qname = cls.getQualifiedName();
CsmFile file = referencedClass.getContainingFile(); CsmProject project = file.getProject(); for (CsmInheritance inh : project.findInheritances(referencedClass.getName())){ CsmClassifier classifier = inh.getClassifier(); if (classifier != null) {
if (cls != null && cls.isValid()) { CsmFile file = cls.getContainingFile(); if (file != null && file.isValid()) { UpdatebleHost host = hosts.get(PersistentKey.createKey(cls)); if (CsmKindUtilities.isClass(scope)){ CsmClass cls = (CsmClass)scope; if (cls.isValid()) { CsmFile file = cls.getContainingFile(); if (file != null && file.isValid()) { UpdatebleHost host = hosts.get(PersistentKey.createKey(cls));
for (CsmMember member : csmClassContainer.getMembers()) { if (CsmKindUtilities.isField(member)) { result.add((CsmField) member); this.classname = csmClassContainer.getQualifiedName().toString(); final String title = " - " + classname; // NOI18N setName(getName() + title);
@Override public CsmFile getContainingFile() { return parent.getContainingFile(); }
@Override public Collection<CsmInheritance> getBaseClasses() { if (inheritances == null) { List<CsmInheritance> res = new ArrayList<>(1); for (CsmInheritance inh : declaration.getBaseClasses()) { if (canSkipInstantiation(inh, mapping)) { res.add(inh); } else { res.add(new Inheritance(inh, this)); } } inheritances = res.isEmpty() ? Collections.<CsmInheritance>emptyList() : res; } return inheritances; }
List<CsmClass> toAnalyze = getClassesContainers(cls); for (CsmClass csmClass : toAnalyze) { for (CsmInheritance inh : csmClass.getBaseClasses()) { CsmClass base = getInheritanceClass(inh); if (base != null && !antiLoop.contains(base.getQualifiedName())) { antiLoop.add(base.getQualifiedName()); CsmObject result = resolveInClass(base, name); if (result != null) {
@Override public Collection<CsmFriend> getFriends() { return declaration.getFriends(); }