@Override public final CharSequence getName() { if (clazz != null) { return clazz.getName(); } return name; }
@Override public CharSequence getClassifierText() { return clazz.getName(); }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o instanceof CsmClassifier) { CsmClassifier c = (CsmClassifier) o; String className = (c.getName() == null) ? null : c.getName().toString().replace('.', '$'); String thisName = name.toString().replace('.', '$'); return thisName.equals(className);//XXX && packageName.equals(c.getPackageName()); } return false; }
public int compareTo(Object o) { if (this == o) { return 0; } CsmClassifier c = (CsmClassifier) o; //XXX int order = packageName.compareTo(c.getPackageName()); int order = 0; if (order == 0) { order = name.toString().compareTo(c.getName().toString()); } return order; }
public SimpleClass(CsmClassifier clazz) { this.clazz = clazz; this.name = clazz.getName(); this.fullName = clazz.getQualifiedName(); }
@Override public void onVisibleClassifier(CsmClassifier cls) { if (CharSequences.comparator().compare(currName(), cls.getName()) == 0) { currLocalClassifier = cls; } } }
public static boolean isPrimitiveClass(CsmClassifier c) { // return (c.getPackageName().length() == 0) // && isPrimitiveClassName(c.getName()); return isPrimitiveClassName(c.getName().toString()); } //
public static CsmType createSimpleType(CsmClassifier cls, CsmFile file, int startOffset, int endOffset) { TypeImpl type = new TypeImpl(file, 0, 0, 0, false, startOffset, endOffset); type.setClassifierText(cls.getName()); List<CharSequence> l = new ArrayList<>(); l.add(cls.getName()); type.setQName(l.toArray(new CharSequence[l.size()])); type.initClassifier(cls); return type; }
private List<CsmClass> getBaseClasses(CsmType varType, CsmClassifier clazz, ExprKind nextKind, boolean exactMatch) { // try base classes names like in this->Base::foo() // or like in a.Base::foo() CsmClassifier varCls = extractTypeClassifier(varType, nextKind); List<CsmClass> baseClasses = null; if (varCls != null) { baseClasses = finder.findBaseClasses(contextElement, clazz, varCls.getName().toString(), exactMatch, this.sort); } return baseClasses; }
public Iterator<CsmClassifier> getNestedClassifiers(CsmClassifier cls, CharSequence name) { Iterator<CsmMember> it = getDeclarations(cls, name); List<CsmClassifier> res = new ArrayList<>(); while(it.hasNext()){ CsmMember m = it.next(); if (CsmKindUtilities.isClassifier(m)){ res.add((CsmClassifier) m); } } if (CsmKindUtilities.isClass(cls) && CsmSortUtilities.matchName(cls.getName(), name, true, true)){ res.add(cls); } return res.iterator(); } }
private static String formatType(CsmType type, boolean useFullName, boolean appendDblComma, boolean appendStar) { StringBuilder sb = new StringBuilder(); if (type != null && type.getClassifier() != null) { // sb.append(type.format(useFullName)); sb.append(useFullName ? type.getClassifier().getQualifiedName() : type.getClassifier().getName()); } if (appendDblComma) { sb.append(CsmCompletion.SCOPE); } if (appendStar) { sb.append('*'); //NOI18N } return sb.toString(); }
private static boolean canBePointer(CsmType type) { if (type instanceof CsmCompletion.OffsetableType) { CsmClassifier typeCls = type.getClassifier(); return CsmCompletion.isPrimitiveClass(typeCls) && CsmCompletion.INT_CLASS.getName().equals(typeCls.getName()) && ((CsmCompletion.OffsetableType) type).isZeroConst(); } return false; }
private static boolean getStateBit(Object object){ if (object instanceof CsmTypedef){ CsmTypedef typedef = (CsmTypedef) object; if (((CsmTypedef)object).isTypeUnnamed()){ CsmClassifier cls = typedef.getType().getClassifier(); if (cls != null && cls.getName().length()==0 && CsmKindUtilities.isCompoundClassifier(cls)) { return true; } } } return false; }
final CharSequence initClassifierText(AST node) { if( node == null ) { CsmClassifier classifier = _getClassifier(); return classifier == null ? "" : classifier.getName(); } else { StringBuilder sb = new StringBuilder(); addText(sb, AstRenderer.getFirstSiblingSkipQualifiers(node)); return TextCache.getManager().getString(sb); // return sb.toString(); } }
CsmClassifier classifier = returnType.getClassifier(); if (classifier != null) { String toReplace = classifier.getName().toString(); if (type.indexOf(toReplace) == 0) { CsmScope scope = classifier.getScope();
TypeImpl(CsmClassifier classifier, int pointerDepth, int reference, int arrayDepth, boolean _const, CsmFile file, int startOffset, int endOffset) { super(file, startOffset, endOffset); this.initClassifier(classifier); this.pointerDepth = (byte) pointerDepth; this.constQualifiers = _const ? 1 : 0; // nothing, & or && as reference specifier // too slow my typing is too slow assert reference >= 0 && reference <= 2 : "unexpected " + reference; setFlags(FLAGS_REFERENCE, reference > 0); setFlags(FLAGS_RVALREFERENCE, reference == 2); this.arrayDepth = (byte) arrayDepth; setFlags(FLAGS_CONST, _const); setFlags(FLAGS_TYPE_WITH_CLASSIFIER, true); this.classifierText = classifier.getName(); trimInstantiationParams(); }
simpleName = ((CsmTemplate)classifier).getDisplayName().toString(); } else { simpleName = classifier.getName().toString();
private CharSequence getTextImpl(boolean instantiate) { if (originalType instanceof org.netbeans.modules.cnd.modelimpl.csm.NestedType) { return ((org.netbeans.modules.cnd.modelimpl.csm.NestedType)originalType).getOwnText(); } if (originalType instanceof NestedType) { return ((NestedType)originalType).getOwnText(); } if (originalType instanceof TypeImpl) { // try to instantiate original classifier CsmClassifier classifier = null; if (instantiate) { classifier = getClassifier(); if (classifier != null) { classifier = CsmBaseUtilities.getOriginalClassifier(classifier, getContainingFile()); } } CharSequence clsText; if (classifier == null || CsmKindUtilities.isInstantiation(classifier)) { clsText = getClassifierText(); } else { clsText = classifier.getName(); } return ((TypeImpl)originalType).decorateText( clsText, this, false, null); } return originalType.getText(); }
} else { setFlags(FLAGS_TYPE_WITH_CLASSIFIER, true); CharSequence typeName = classifier.getName(); if (typeName == null || typeName.length()==0){ this.classifierText = initClassifierText(ast);