2 * Copyright (C) 2008 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 import com.sun.javadoc.*;
18 import com.sun.tools.doclets.*;
19 import org.clearsilver.HDF;
20 import org.clearsilver.CS;
24 public class ClassInfo extends DocInfo implements ContainerInfo, Comparable, Scoped
26 public static final Comparator<ClassInfo> comparator = new Comparator<ClassInfo>() {
27 public int compare(ClassInfo a, ClassInfo b) {
28 return a.name().compareTo(b.name());
32 public static final Comparator<ClassInfo> qualifiedComparator = new Comparator<ClassInfo>() {
33 public int compare(ClassInfo a, ClassInfo b) {
34 return a.qualifiedName().compareTo(b.qualifiedName());
40 String rawCommentText, SourcePositionInfo position,
41 boolean isPublic, boolean isProtected, boolean isPackagePrivate,
42 boolean isPrivate, boolean isStatic,
43 boolean isInterface, boolean isAbstract, boolean isOrdinaryClass,
44 boolean isException, boolean isError, boolean isEnum, boolean isAnnotation,
45 boolean isFinal, boolean isIncluded, String name,
46 String qualifiedName, String qualifiedTypeName, boolean isPrimitive)
48 super(rawCommentText, position);
52 mIsProtected = isProtected;
53 mIsPackagePrivate = isPackagePrivate;
54 mIsPrivate = isPrivate;
56 mIsInterface = isInterface;
57 mIsAbstract = isAbstract;
58 mIsOrdinaryClass = isOrdinaryClass;
59 mIsException = isException;
62 mIsAnnotation = isAnnotation;
64 mIsIncluded = isIncluded;
66 mQualifiedName = qualifiedName;
67 mQualifiedTypeName = qualifiedTypeName;
68 mIsPrimitive = isPrimitive;
69 mNameParts = name.split("\\.");
72 public void init(TypeInfo typeInfo, ClassInfo[] interfaces, TypeInfo[] interfaceTypes,
73 ClassInfo[] innerClasses,
74 MethodInfo[] constructors, MethodInfo[] methods, MethodInfo[] annotationElements,
75 FieldInfo[] fields, FieldInfo[] enumConstants,
76 PackageInfo containingPackage, ClassInfo containingClass,
77 ClassInfo superclass, TypeInfo superclassType, AnnotationInstanceInfo[] annotations)
80 mRealInterfaces = interfaces;
81 mRealInterfaceTypes = interfaceTypes;
82 mInnerClasses = innerClasses;
83 mAllConstructors = constructors;
84 mAllSelfMethods = methods;
85 mAnnotationElements = annotationElements;
86 mAllSelfFields = fields;
87 mEnumConstants = enumConstants;
88 mContainingPackage = containingPackage;
89 mContainingClass = containingClass;
90 mRealSuperclass = superclass;
91 mRealSuperclassType = superclassType;
92 mAnnotations = annotations;
94 // after providing new methods and new superclass info,clear any cached
95 // lists of self + superclass methods, ctors, etc.
96 mSuperclassInit = false;
102 mSelfAttributes = null;
103 mDeprecatedKnown = false;
105 Arrays.sort(mEnumConstants, FieldInfo.comparator);
106 Arrays.sort(mInnerClasses, ClassInfo.comparator);
109 public void init2() {
110 // calling this here forces the AttrTagInfo objects to be linked to the AttribtueInfo
115 public void init3(TypeInfo[] types, ClassInfo[] realInnerClasses){
116 mTypeParameters = types;
117 mRealInnerClasses = realInnerClasses;
120 public ClassInfo[] getRealInnerClasses(){
121 return mRealInnerClasses;
124 public TypeInfo[] getTypeParameters(){
125 return mTypeParameters;
128 public boolean checkLevel()
130 int val = mCheckLevel;
134 boolean v = DroidDoc.checkLevel(mIsPublic, mIsProtected,
135 mIsPackagePrivate, mIsPrivate, isHidden());
136 mCheckLevel = v ? 1 : 0;
141 public int compareTo(Object that) {
142 if (that instanceof ClassInfo) {
143 return mQualifiedName.compareTo(((ClassInfo)that).mQualifiedName);
145 return this.hashCode() - that.hashCode();
149 public ContainerInfo parent()
154 public boolean isPublic()
159 public boolean isProtected()
164 public boolean isPackagePrivate()
166 return mIsPackagePrivate;
169 public boolean isPrivate()
174 public boolean isStatic()
179 public boolean isInterface()
184 public boolean isAbstract()
189 public PackageInfo containingPackage()
191 return mContainingPackage;
194 public ClassInfo containingClass()
196 return mContainingClass;
199 public boolean isOrdinaryClass()
201 return mIsOrdinaryClass;
204 public boolean isException()
209 public boolean isError()
214 public boolean isEnum()
219 public boolean isAnnotation()
221 return mIsAnnotation;
224 public boolean isFinal()
229 public boolean isIncluded()
234 public HashSet<String> typeVariables()
236 HashSet<String> result = TypeInfo.typeVariables(mTypeInfo.typeArguments());
237 ClassInfo cl = containingClass();
239 TypeInfo[] types = cl.asTypeInfo().typeArguments();
241 TypeInfo.typeVariables(types, result);
243 cl = cl.containingClass();
248 private static void gatherHiddenInterfaces(ClassInfo cl, HashSet<ClassInfo> interfaces) {
249 for (ClassInfo iface: cl.mRealInterfaces) {
250 if (iface.checkLevel()) {
251 interfaces.add(iface);
253 gatherHiddenInterfaces(iface, interfaces);
258 public ClassInfo[] interfaces()
260 if (mInterfaces == null) {
262 HashSet<ClassInfo> interfaces = new HashSet<ClassInfo>();
263 ClassInfo superclass = mRealSuperclass;
264 while (superclass != null && !superclass.checkLevel()) {
265 gatherHiddenInterfaces(superclass, interfaces);
266 superclass = superclass.mRealSuperclass;
268 gatherHiddenInterfaces(this, interfaces);
269 mInterfaces = interfaces.toArray(new ClassInfo[interfaces.size()]);
271 // put something here in case someone uses it
272 mInterfaces = mRealInterfaces;
274 Arrays.sort(mInterfaces, ClassInfo.qualifiedComparator);
279 public ClassInfo[] realInterfaces()
281 return mRealInterfaces;
284 TypeInfo[] realInterfaceTypes()
286 return mRealInterfaceTypes;
294 public String[] nameParts()
299 public String leafName()
301 return mNameParts[mNameParts.length-1];
304 public String qualifiedName()
306 return mQualifiedName;
309 public String qualifiedTypeName()
311 return mQualifiedTypeName;
314 public boolean isPrimitive()
319 public MethodInfo[] allConstructors() {
320 return mAllConstructors;
323 public MethodInfo[] constructors()
325 if (mConstructors == null) {
326 MethodInfo[] methods = mAllConstructors;
327 ArrayList<MethodInfo> ctors = new ArrayList<MethodInfo>();
328 for (int i=0; i<methods.length; i++) {
329 MethodInfo m = methods[i];
334 mConstructors = ctors.toArray(new MethodInfo[ctors.size()]);
335 Arrays.sort(mConstructors, MethodInfo.comparator);
337 return mConstructors;
340 public ClassInfo[] innerClasses()
342 return mInnerClasses;
345 public TagInfo[] inlineTags()
347 return comment().tags();
350 public TagInfo[] firstSentenceTags()
352 return comment().briefTags();
355 public boolean isDeprecated() {
356 boolean deprecated = false;
357 if (!mDeprecatedKnown) {
358 boolean commentDeprecated = (comment().deprecatedTags().length > 0);
359 boolean annotationDeprecated = false;
360 for (AnnotationInstanceInfo annotation : annotations()) {
361 if (annotation.type().qualifiedName().equals("java.lang.Deprecated")) {
362 annotationDeprecated = true;
367 if (commentDeprecated != annotationDeprecated) {
368 Errors.error(Errors.DEPRECATION_MISMATCH, position(),
369 "Class " + qualifiedName()
370 + ": @Deprecated annotation and @deprecated comment do not match");
373 mIsDeprecated = commentDeprecated | annotationDeprecated;
374 mDeprecatedKnown = true;
376 return mIsDeprecated;
379 public TagInfo[] deprecatedTags()
381 // Should we also do the interfaces?
382 return comment().deprecatedTags();
385 public MethodInfo[] methods()
387 if (mMethods == null) {
388 TreeMap<String,MethodInfo> all = new TreeMap<String,MethodInfo>();
390 ClassInfo[] ifaces = interfaces();
391 for (ClassInfo iface: ifaces) {
393 MethodInfo[] inhereted = iface.methods();
394 for (MethodInfo method: inhereted) {
395 String key = method.name() + method.signature();
396 all.put(key, method);
401 ClassInfo superclass = superclass();
402 if (superclass != null) {
403 MethodInfo[] inhereted = superclass.methods();
404 for (MethodInfo method: inhereted) {
405 String key = method.name() + method.signature();
406 all.put(key, method);
410 MethodInfo[] methods = selfMethods();
411 for (MethodInfo method: methods) {
412 String key = method.name() + method.signature();
413 MethodInfo old = all.put(key, method);
416 mMethods = all.values().toArray(new MethodInfo[all.size()]);
421 public MethodInfo[] annotationElements()
423 return mAnnotationElements;
426 public AnnotationInstanceInfo[] annotations()
431 private static void addFields(ClassInfo cl, TreeMap<String,FieldInfo> all)
433 FieldInfo[] fields = cl.fields();
434 int N = fields.length;
435 for (int i=0; i<N; i++) {
436 FieldInfo f = fields[i];
437 all.put(f.name(), f);
441 public FieldInfo[] fields()
443 if (mFields == null) {
445 TreeMap<String,FieldInfo> all = new TreeMap<String,FieldInfo>();
447 ClassInfo[] interfaces = interfaces();
448 N = interfaces.length;
449 for (int i=0; i<N; i++) {
450 addFields(interfaces[i], all);
453 ClassInfo superclass = superclass();
454 if (superclass != null) {
455 addFields(superclass, all);
458 FieldInfo[] fields = selfFields();
460 for (int i=0; i<N; i++) {
461 FieldInfo f = fields[i];
463 String key = f.name();
468 mFields = all.values().toArray(new FieldInfo[0]);
473 public void gatherFields(ClassInfo owner, ClassInfo cl, HashMap<String,FieldInfo> fields) {
474 FieldInfo[] flds = cl.selfFields();
475 for (FieldInfo f: flds) {
476 if (f.checkLevel()) {
477 fields.put(f.name(), f.cloneForClass(owner));
482 public FieldInfo[] selfFields()
484 if (mSelfFields == null) {
485 HashMap<String,FieldInfo> fields = new HashMap<String,FieldInfo>();
486 // our hidden parents
487 if (mRealSuperclass != null && !mRealSuperclass.checkLevel()) {
488 gatherFields(this, mRealSuperclass, fields);
490 for (ClassInfo iface: mRealInterfaces) {
491 if (!iface.checkLevel()) {
492 gatherFields(this, iface, fields);
496 FieldInfo[] selfFields = mAllSelfFields;
497 for (int i=0; i<selfFields.length; i++) {
498 FieldInfo f = selfFields[i];
500 fields.put(f.name(), f);
503 // combine and return in
504 mSelfFields = fields.values().toArray(new FieldInfo[fields.size()]);
505 Arrays.sort(mSelfFields, FieldInfo.comparator);
510 public FieldInfo[] allSelfFields() {
511 return mAllSelfFields;
514 public void gatherMethods(ClassInfo owner, ClassInfo cl, HashMap<String,MethodInfo> methods) {
515 MethodInfo[] meth = cl.selfMethods();
516 for (MethodInfo m: meth) {
517 if (m.checkLevel()) {
518 methods.put(m.name()+m.signature(), m.cloneForClass(owner));
523 public MethodInfo[] selfMethods()
525 if (mSelfMethods == null) {
526 HashMap<String,MethodInfo> methods = new HashMap<String,MethodInfo>();
527 // our hidden parents
528 if (mRealSuperclass != null && !mRealSuperclass.checkLevel()) {
529 gatherMethods(this, mRealSuperclass, methods);
531 for (ClassInfo iface: mRealInterfaces) {
532 if (!iface.checkLevel()) {
533 gatherMethods(this, iface, methods);
537 MethodInfo[] selfMethods = mAllSelfMethods;
538 for (int i=0; i<selfMethods.length; i++) {
539 MethodInfo m = selfMethods[i];
540 if (m.checkLevel()) {
541 methods.put(m.name()+m.signature(), m);
544 // combine and return it
545 mSelfMethods = methods.values().toArray(new MethodInfo[methods.size()]);
546 Arrays.sort(mSelfMethods, MethodInfo.comparator);
551 public MethodInfo[] allSelfMethods() {
552 return mAllSelfMethods;
555 public void addMethod(MethodInfo method) {
556 MethodInfo[] methods = new MethodInfo[mAllSelfMethods.length + 1];
558 for (MethodInfo m : mAllSelfMethods) {
563 mAllSelfMethods = methods;
566 public AttributeInfo[] selfAttributes()
568 if (mSelfAttributes == null) {
569 TreeMap<FieldInfo,AttributeInfo> attrs = new TreeMap<FieldInfo,AttributeInfo>();
571 // the ones in the class comment won't have any methods
572 for (AttrTagInfo tag: comment().attrTags()) {
573 FieldInfo field = tag.reference();
575 AttributeInfo attr = attrs.get(field);
577 attr = new AttributeInfo(this, field);
578 attrs.put(field, attr);
580 tag.setAttribute(attr);
585 for (MethodInfo m: selfMethods()) {
586 for (AttrTagInfo tag: m.comment().attrTags()) {
587 FieldInfo field = tag.reference();
589 AttributeInfo attr = attrs.get(field);
591 attr = new AttributeInfo(this, field);
592 attrs.put(field, attr);
594 tag.setAttribute(attr);
601 for (MethodInfo m: constructors()) {
602 for (AttrTagInfo tag: m.comment().attrTags()) {
603 FieldInfo field = tag.reference();
605 AttributeInfo attr = attrs.get(field);
607 attr = new AttributeInfo(this, field);
608 attrs.put(field, attr);
610 tag.setAttribute(attr);
616 mSelfAttributes = attrs.values().toArray(new AttributeInfo[attrs.size()]);
617 Arrays.sort(mSelfAttributes, AttributeInfo.comparator);
619 return mSelfAttributes;
622 public FieldInfo[] enumConstants()
624 return mEnumConstants;
627 public ClassInfo superclass()
629 if (!mSuperclassInit) {
630 if (this.checkLevel()) {
631 // rearrange our little inheritance hierarchy, because we need to hide classes that
632 // don't pass checkLevel
633 ClassInfo superclass = mRealSuperclass;
634 while (superclass != null && !superclass.checkLevel()) {
635 superclass = superclass.mRealSuperclass;
637 mSuperclass = superclass;
639 mSuperclass = mRealSuperclass;
645 public ClassInfo realSuperclass()
647 return mRealSuperclass;
650 /** always the real superclass, not the collapsed one we get through superclass(),
651 * also has the type parameter info if it's generic.
653 public TypeInfo superclassType()
655 return mRealSuperclassType;
658 public TypeInfo asTypeInfo()
663 TypeInfo[] interfaceTypes()
665 ClassInfo[] infos = interfaces();
666 int len = infos.length;
667 TypeInfo[] types = new TypeInfo[len];
668 for (int i=0; i<len; i++) {
669 types[i] = infos[i].asTypeInfo();
674 public String htmlPage()
676 String s = containingPackage().name();
677 s = s.replace('.', '/');
681 s = DroidDoc.javadocDir + s;
685 /** Even indirectly */
686 public boolean isDerivedFrom(ClassInfo cl)
688 ClassInfo dad = this.superclass();
690 if (dad.equals(cl)) {
693 if (dad.isDerivedFrom(cl)) {
698 for (ClassInfo iface: interfaces()) {
699 if (iface.equals(cl)) {
702 if (iface.isDerivedFrom(cl)) {
710 public void makeKeywordEntries(List<KeywordEntry> keywords)
716 String htmlPage = htmlPage();
717 String qualifiedName = qualifiedName();
719 keywords.add(new KeywordEntry(name(), htmlPage,
720 "class in " + containingPackage().name()));
722 FieldInfo[] fields = selfFields();
723 FieldInfo[] enumConstants = enumConstants();
724 MethodInfo[] ctors = constructors();
725 MethodInfo[] methods = selfMethods();
728 for (FieldInfo field: enumConstants()) {
729 if (field.checkLevel()) {
730 keywords.add(new KeywordEntry(field.name(),
731 htmlPage + "#" + field.anchor(),
732 "enum constant in " + qualifiedName));
737 for (FieldInfo field: fields) {
738 if (field.isConstant() && field.checkLevel()) {
739 keywords.add(new KeywordEntry(field.name(),
740 htmlPage + "#" + field.anchor(),
741 "constant in " + qualifiedName));
746 for (FieldInfo field: fields) {
747 if (!field.isConstant() && field.checkLevel()) {
748 keywords.add(new KeywordEntry(field.name(),
749 htmlPage + "#" + field.anchor(),
750 "field in " + qualifiedName));
754 // public constructors
755 for (MethodInfo m: ctors) {
756 if (m.isPublic() && m.checkLevel()) {
757 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
758 htmlPage + "#" + m.anchor(),
759 "constructor in " + qualifiedName));
763 // protected constructors
764 if (DroidDoc.checkLevel(DroidDoc.SHOW_PROTECTED)) {
765 for (MethodInfo m: ctors) {
766 if (m.isProtected() && m.checkLevel()) {
767 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
768 htmlPage + "#" + m.anchor(),
769 "constructor in " + qualifiedName));
774 // package private constructors
775 if (DroidDoc.checkLevel(DroidDoc.SHOW_PACKAGE)) {
776 for (MethodInfo m: ctors) {
777 if (m.isPackagePrivate() && m.checkLevel()) {
778 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
779 htmlPage + "#" + m.anchor(),
780 "constructor in " + qualifiedName));
785 // private constructors
786 if (DroidDoc.checkLevel(DroidDoc.SHOW_PRIVATE)) {
787 for (MethodInfo m: ctors) {
788 if (m.isPrivate() && m.checkLevel()) {
789 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
790 htmlPage + "#" + m.anchor(),
791 "constructor in " + qualifiedName));
797 for (MethodInfo m: methods) {
798 if (m.isPublic() && m.checkLevel()) {
799 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
800 htmlPage + "#" + m.anchor(),
801 "method in " + qualifiedName));
806 if (DroidDoc.checkLevel(DroidDoc.SHOW_PROTECTED)) {
807 for (MethodInfo m: methods) {
808 if (m.isProtected() && m.checkLevel()) {
809 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
810 htmlPage + "#" + m.anchor(),
811 "method in " + qualifiedName));
816 // package private methods
817 if (DroidDoc.checkLevel(DroidDoc.SHOW_PACKAGE)) {
818 for (MethodInfo m: methods) {
819 if (m.isPackagePrivate() && m.checkLevel()) {
820 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
821 htmlPage + "#" + m.anchor(),
822 "method in " + qualifiedName));
828 if (DroidDoc.checkLevel(DroidDoc.SHOW_PRIVATE)) {
829 for (MethodInfo m: methods) {
830 if (m.isPrivate() && m.checkLevel()) {
831 keywords.add(new KeywordEntry(m.name() + m.prettySignature(),
832 htmlPage + "#" + m.anchor(),
833 "method in " + qualifiedName));
839 public void makeLink(HDF data, String base)
841 data.setValue(base + ".label", this.name());
842 if (!this.isPrimitive() && this.isIncluded() && this.checkLevel()) {
843 data.setValue(base + ".link", this.htmlPage());
847 public static void makeLinkListHDF(HDF data, String base, ClassInfo[] classes) {
848 final int N = classes.length;
849 for (int i=0; i<N; i++) {
850 ClassInfo cl = classes[i];
851 if (cl.checkLevel()) {
852 cl.asTypeInfo().makeHDF(data, base + "." + i);
858 * Used in lists of this class (packages, nested classes, known subclasses)
860 public void makeShortDescrHDF(HDF data, String base)
862 mTypeInfo.makeHDF(data, base + ".type");
863 data.setValue(base + ".kind", this.kind());
864 TagInfo.makeHDF(data, base + ".shortDescr", this.firstSentenceTags());
865 TagInfo.makeHDF(data, base + ".deprecated", deprecatedTags());
869 * Turns into the main class page
871 public void makeHDF(HDF data)
874 String name = name();
875 String qualified = qualifiedName();
876 AttributeInfo[] selfAttributes = selfAttributes();
877 MethodInfo[] methods = selfMethods();
878 FieldInfo[] fields = selfFields();
879 FieldInfo[] enumConstants = enumConstants();
880 MethodInfo[] ctors = constructors();
881 ClassInfo[] inners = innerClasses();
884 mTypeInfo.makeHDF(data, "class.type");
885 mTypeInfo.makeQualifiedHDF(data, "class.qualifiedType");
886 data.setValue("class.name", name);
887 data.setValue("class.qualified", qualified);
890 data.setValue("class.scope", "protected");
892 else if (isPublic()) {
893 data.setValue("class.scope", "public");
896 data.setValue("class.static", "static");
899 data.setValue("class.final", "final");
901 if (isAbstract() && !isInterface()) {
902 data.setValue("class.abstract", "abstract");
906 String kind = kind();
908 data.setValue("class.kind", kind);
911 // the containing package -- note that this can be passed to type_link,
912 // but it also contains the list of all of the packages
913 containingPackage().makeClassLinkListHDF(data, "class.package");
915 // inheritance hierarchy
916 Vector<ClassInfo> superClasses = new Vector<ClassInfo>();
917 superClasses.add(this);
918 ClassInfo supr = superclass();
919 while (supr != null) {
920 superClasses.add(supr);
921 supr = supr.superclass();
923 n = superClasses.size();
924 for (i=0; i<n; i++) {
925 supr = superClasses.elementAt(n-i-1);
927 supr.asTypeInfo().makeQualifiedHDF(data, "class.inheritance." + i + ".class");
928 supr.asTypeInfo().makeHDF(data, "class.inheritance." + i + ".short_class");
930 for (TypeInfo t: supr.interfaceTypes()) {
931 t.makeHDF(data, "class.inheritance." + i + ".interfaces." + j);
937 TagInfo.makeHDF(data, "class.descr", inlineTags());
938 TagInfo.makeHDF(data, "class.seeAlso", comment().seeTags());
939 TagInfo.makeHDF(data, "class.deprecated", deprecatedTags());
942 TreeMap<String, ClassInfo> direct = new TreeMap<String, ClassInfo>();
943 TreeMap<String, ClassInfo> indirect = new TreeMap<String, ClassInfo>();
944 ClassInfo[] all = Converter.rootClasses();
945 for (ClassInfo cl: all) {
946 if (cl.superclass() != null && cl.superclass().equals(this)) {
947 direct.put(cl.name(), cl);
949 else if (cl.isDerivedFrom(this)) {
950 indirect.put(cl.name(), cl);
955 for (ClassInfo cl: direct.values()) {
956 if (cl.checkLevel()) {
957 cl.makeShortDescrHDF(data, "class.subclasses.direct." + i);
963 for (ClassInfo cl: indirect.values()) {
964 if (cl.checkLevel()) {
965 cl.makeShortDescrHDF(data, "class.subclasses.indirect." + i);
972 for (ClassInfo inner: inners) {
973 if (inner.checkLevel()) {
974 inner.makeShortDescrHDF(data, "class.inners." + i);
981 for (FieldInfo field: enumConstants) {
982 if (field.isConstant()) {
983 field.makeHDF(data, "class.enumConstants." + i);
990 for (FieldInfo field: fields) {
991 if (field.isConstant()) {
992 field.makeHDF(data, "class.constants." + i);
999 for (FieldInfo field: fields) {
1000 if (!field.isConstant()) {
1001 field.makeHDF(data, "class.fields." + i);
1006 // public constructors
1008 for (MethodInfo ctor: ctors) {
1009 if (ctor.isPublic()) {
1010 ctor.makeHDF(data, "class.ctors.public." + i);
1015 // protected constructors
1016 if (DroidDoc.checkLevel(DroidDoc.SHOW_PROTECTED)) {
1018 for (MethodInfo ctor: ctors) {
1019 if (ctor.isProtected()) {
1020 ctor.makeHDF(data, "class.ctors.protected." + i);
1026 // package private constructors
1027 if (DroidDoc.checkLevel(DroidDoc.SHOW_PACKAGE)) {
1029 for (MethodInfo ctor: ctors) {
1030 if (ctor.isPackagePrivate()) {
1031 ctor.makeHDF(data, "class.ctors.package." + i);
1037 // private constructors
1038 if (DroidDoc.checkLevel(DroidDoc.SHOW_PRIVATE)) {
1040 for (MethodInfo ctor: ctors) {
1041 if (ctor.isPrivate()) {
1042 ctor.makeHDF(data, "class.ctors.private." + i);
1050 for (MethodInfo method: methods) {
1051 if (method.isPublic()) {
1052 method.makeHDF(data, "class.methods.public." + i);
1057 // protected methods
1058 if (DroidDoc.checkLevel(DroidDoc.SHOW_PROTECTED)) {
1060 for (MethodInfo method: methods) {
1061 if (method.isProtected()) {
1062 method.makeHDF(data, "class.methods.protected." + i);
1068 // package private methods
1069 if (DroidDoc.checkLevel(DroidDoc.SHOW_PACKAGE)) {
1071 for (MethodInfo method: methods) {
1072 if (method.isPackagePrivate()) {
1073 method.makeHDF(data, "class.methods.package." + i);
1080 if (DroidDoc.checkLevel(DroidDoc.SHOW_PRIVATE)) {
1082 for (MethodInfo method: methods) {
1083 if (method.isPrivate()) {
1084 method.makeHDF(data, "class.methods.private." + i);
1092 for (AttributeInfo attr: selfAttributes) {
1093 if (attr.checkLevel()) {
1094 attr.makeHDF(data, "class.attrs." + i);
1099 // inherited methods
1100 Set<ClassInfo> interfaces = new TreeSet<ClassInfo>();
1101 addInterfaces(interfaces(), interfaces);
1102 ClassInfo cl = superclass();
1104 while (cl != null) {
1105 addInterfaces(cl.interfaces(), interfaces);
1106 makeInheritedHDF(data, i, cl);
1107 cl = cl.superclass();
1110 for (ClassInfo iface: interfaces) {
1111 makeInheritedHDF(data, i, iface);
1116 private static void addInterfaces(ClassInfo[] ifaces, Set<ClassInfo> out)
1118 for (ClassInfo cl: ifaces) {
1120 addInterfaces(cl.interfaces(), out);
1124 private static void makeInheritedHDF(HDF data, int index, ClassInfo cl)
1128 String base = "class.inherited." + index;
1129 data.setValue(base + ".qualified", cl.qualifiedName());
1130 if (cl.checkLevel()) {
1131 data.setValue(base + ".link", cl.htmlPage());
1133 String kind = cl.kind();
1135 data.setValue(base + ".kind", kind);
1140 for (AttributeInfo attr: cl.selfAttributes()) {
1141 attr.makeHDF(data, base + ".attrs." + i);
1147 for (MethodInfo method: cl.selfMethods()) {
1148 method.makeHDF(data, base + ".methods." + i);
1154 for (FieldInfo field: cl.selfFields()) {
1155 if (!field.isConstant()) {
1156 field.makeHDF(data, base + ".fields." + i);
1163 for (FieldInfo field: cl.selfFields()) {
1164 if (field.isConstant()) {
1165 field.makeHDF(data, base + ".constants." + i);
1171 public boolean isHidden()
1177 boolean v = isHiddenImpl();
1178 mHidden = v ? 1 : 0;
1183 public boolean isHiddenImpl()
1185 ClassInfo cl = this;
1186 while (cl != null) {
1187 PackageInfo pkg = cl.containingPackage();
1188 if (pkg != null && pkg.isHidden()) {
1191 if (cl.comment().isHidden()) {
1194 cl = cl.containingClass();
1199 private MethodInfo matchMethod(MethodInfo[] methods, String name,
1200 String[] params, String[] dimensions)
1202 int len = methods.length;
1203 for (int i=0; i<len; i++) {
1204 MethodInfo method = methods[i];
1205 if (method.name().equals(name)) {
1206 if (params == null) {
1209 if (method.matchesParams(params, dimensions)) {
1218 public MethodInfo findMethod(String name,
1219 String[] params, String[] dimensions)
1221 // first look on our class, and our superclasses
1225 rv = matchMethod(methods(), name, params, dimensions);
1232 rv = matchMethod(constructors(), name, params, dimensions);
1237 // then recursively look at our containing class
1238 ClassInfo containing = containingClass();
1239 if (containing != null) {
1240 return containing.findMethod(name, params, dimensions);
1246 private ClassInfo searchInnerClasses(String[] nameParts, int index)
1248 String part = nameParts[index];
1250 ClassInfo[] inners = mInnerClasses;
1251 for (ClassInfo in: inners) {
1252 String[] innerParts = in.nameParts();
1253 if (part.equals(innerParts[innerParts.length-1])) {
1254 if (index == nameParts.length-1) {
1257 return in.searchInnerClasses(nameParts, index+1);
1264 public ClassInfo extendedFindClass(String className)
1266 // ClassDoc.findClass has this bug that we're working around here:
1267 // If you have a class PackageManager with an inner class PackageInfo
1268 // and you call it with "PackageInfo" it doesn't find it.
1269 return searchInnerClasses(className.split("\\."), 0);
1272 public ClassInfo findClass(String className)
1274 return Converter.obtainClass(mClass.findClass(className));
1277 public ClassInfo findInnerClass(String className)
1279 // ClassDoc.findClass won't find inner classes. To deal with that,
1280 // we try what they gave us first, but if that didn't work, then
1281 // we see if there are any periods in className, and start searching
1283 String[] nodes = className.split("\\.");
1284 ClassDoc cl = mClass;
1285 for (String n: nodes) {
1286 cl = cl.findClass(n);
1291 return Converter.obtainClass(cl);
1294 public FieldInfo findField(String name)
1296 // first look on our class, and our superclasses
1297 for (FieldInfo f: fields()) {
1298 if (f.name().equals(name)) {
1303 // then look at our enum constants (these are really fields, maybe
1304 // they should be mixed into fields(). not sure)
1305 for (FieldInfo f: enumConstants()) {
1306 if (f.name().equals(name)) {
1311 // then recursively look at our containing class
1312 ClassInfo containing = containingClass();
1313 if (containing != null) {
1314 return containing.findField(name);
1320 public static ClassInfo[] sortByName(ClassInfo[] classes)
1323 Sorter[] sorted = new Sorter[classes.length];
1324 for (i=0; i<sorted.length; i++) {
1325 ClassInfo cl = classes[i];
1326 sorted[i] = new Sorter(cl.name(), cl);
1329 Arrays.sort(sorted);
1331 ClassInfo[] rv = new ClassInfo[classes.length];
1332 for (i=0; i<rv.length; i++) {
1333 rv[i] = (ClassInfo)sorted[i].data;
1339 public boolean equals(ClassInfo that)
1342 return this.qualifiedName().equals(that.qualifiedName());
1348 public void setNonWrittenConstructors(MethodInfo[] nonWritten) {
1349 mNonWrittenConstructors = nonWritten;
1352 public MethodInfo[] getNonWrittenConstructors() {
1353 return mNonWrittenConstructors;
1356 public String kind()
1358 if (isOrdinaryClass()) {
1361 else if (isInterface()) {
1364 else if (isEnum()) {
1367 else if (isError()) {
1370 else if (isException()) {
1373 else if (isAnnotation()) {
1374 return "@interface";
1379 public void setHiddenMethods(MethodInfo[] mInfo){
1380 mHiddenMethods = mInfo;
1382 public MethodInfo[] getHiddenMethods(){
1383 return mHiddenMethods;
1385 public String toString(){
1386 return this.qualifiedName();
1389 public void setReasonIncluded(String reason) {
1390 mReasonIncluded = reason;
1393 public String getReasonIncluded() {
1394 return mReasonIncluded;
1397 private ClassDoc mClass;
1400 private boolean mIsPublic;
1401 private boolean mIsProtected;
1402 private boolean mIsPackagePrivate;
1403 private boolean mIsPrivate;
1404 private boolean mIsStatic;
1405 private boolean mIsInterface;
1406 private boolean mIsAbstract;
1407 private boolean mIsOrdinaryClass;
1408 private boolean mIsException;
1409 private boolean mIsError;
1410 private boolean mIsEnum;
1411 private boolean mIsAnnotation;
1412 private boolean mIsFinal;
1413 private boolean mIsIncluded;
1414 private String mName;
1415 private String mQualifiedName;
1416 private String mQualifiedTypeName;
1417 private boolean mIsPrimitive;
1418 private TypeInfo mTypeInfo;
1419 private String[] mNameParts;
1422 private ClassInfo[] mRealInterfaces;
1423 private ClassInfo[] mInterfaces;
1424 private TypeInfo[] mRealInterfaceTypes;
1425 private ClassInfo[] mInnerClasses;
1426 private MethodInfo[] mAllConstructors;
1427 private MethodInfo[] mAllSelfMethods;
1428 private MethodInfo[] mAnnotationElements; // if this class is an annotation
1429 private FieldInfo[] mAllSelfFields;
1430 private FieldInfo[] mEnumConstants;
1431 private PackageInfo mContainingPackage;
1432 private ClassInfo mContainingClass;
1433 private ClassInfo mRealSuperclass;
1434 private TypeInfo mRealSuperclassType;
1435 private ClassInfo mSuperclass;
1436 private AnnotationInstanceInfo[] mAnnotations;
1437 private boolean mSuperclassInit;
1438 private boolean mDeprecatedKnown;
1441 private MethodInfo[] mConstructors;
1442 private ClassInfo[] mRealInnerClasses;
1443 private MethodInfo[] mSelfMethods;
1444 private FieldInfo[] mSelfFields;
1445 private AttributeInfo[] mSelfAttributes;
1446 private MethodInfo[] mMethods;
1447 private FieldInfo[] mFields;
1448 private TypeInfo[] mTypeParameters;
1449 private MethodInfo[] mHiddenMethods;
1450 private int mHidden = -1;
1451 private int mCheckLevel = -1;
1452 private String mReasonIncluded;
1453 private MethodInfo[] mNonWrittenConstructors;
1454 private boolean mIsDeprecated;