private static void addAllInterfaceTypes(
Map<ClassDoc, Type> results,
Type type,
Type[] interfaceTypes,
boolean raw,
Configuration configuration) {
for (int i = 0; i < interfaceTypes.length; i++) {
Type interfaceType = interfaceTypes[i];
ClassDoc interfaceClassDoc = interfaceType.asClassDoc();
if (!(interfaceClassDoc.isPublic()
|| (configuration != null && isLinkable(interfaceClassDoc, configuration)))) {
continue;
}
if (raw) interfaceType = interfaceType.asClassDoc();
results.put(interfaceClassDoc, interfaceType);
List<Type> superInterfaces = getAllInterfaces(interfaceType, configuration);
for (Iterator<Type> iter = superInterfaces.iterator(); iter.hasNext(); ) {
Type superInterface = iter.next();
results.put(superInterface.asClassDoc(), superInterface);
}
}
if (type instanceof ParameterizedType)
findAllInterfaceTypes(results, (ParameterizedType) type, configuration);
else if (((ClassDoc) type).typeParameters().length == 0)
findAllInterfaceTypes(results, (ClassDoc) type, raw, configuration);
else findAllInterfaceTypes(results, (ClassDoc) type, true, configuration);
}
/**
* Generate mapping for the sub-classes for every class in this run. Return the sub-class list for
* java.lang.Object which will be having sub-class listing for itself and also for each sub-class
* itself will have their own sub-class lists.
*
* @param classes all the classes in this run.
* @param configuration the current configuration of the doclet.
*/
private void buildTree(ClassDoc[] classes, Configuration configuration) {
log.info("ClassTree buildTree");
for (int i = 0; i < classes.length; i++) {
if (configuration.nodeprecated && classes[i].tags("deprecated").length > 0) {
continue;
}
if (classes[i].isEnum()) {
processType(classes[i], configuration, baseEnums, subEnums);
} else if (classes[i].isClass()) {
processType(classes[i], configuration, baseclasses, subclasses);
} else if (classes[i].isInterface()) {
processInterface(classes[i]);
List list = (List) implementingclasses.get(classes[i]);
if (list != null) {
Collections.sort(list);
}
} else if (classes[i].isAnnotationType()) {
processType(classes[i], configuration, baseAnnotationTypes, subAnnotationTypes);
}
}
Collections.sort(baseinterfaces);
for (Iterator it = subinterfaces.values().iterator(); it.hasNext(); ) {
Collections.sort((List) it.next());
}
for (Iterator it = subclasses.values().iterator(); it.hasNext(); ) {
Collections.sort((List) it.next());
}
}
public static void register(Map tagletMap) {
BoldTaglet tag = new BoldTaglet();
Taglet t = (Taglet) tagletMap.get(tag.getName());
if (t != null) {
tagletMap.remove(tag.getName());
}
tagletMap.put(tag.getName(), tag);
}
/**
* Adjust the Class Tree. Add the class interface in to it's super-class' or super-interface's
* sub-interface list.
*
* @param map the entire map.
* @param superclass java.lang.Object or the super-interface.
* @param cd sub-interface to be mapped.
* @returns boolean true if class added, false if class already processed.
*/
private boolean add(Map map, ClassDoc superclass, ClassDoc cd) {
List list = (List) map.get(superclass);
if (list == null) {
list = new ArrayList();
map.put(superclass, list);
}
if (list.contains(cd)) {
return false;
} else {
list.add(cd);
}
return true;
}
/**
* From the map return the list of sub-classes or sub-interfaces. If list is null create a new one
* and return it.
*
* @param map The entire map.
* @param cd class for which the sub-class list is requested.
* @returns List Sub-Class list for the class passed.
*/
private List get(Map map, ClassDoc cd) {
List list = (List) map.get(cd);
if (list == null) {
return new ArrayList();
}
return list;
}
/**
* For the class return all implemented interfaces including the superinterfaces of the
* implementing interfaces, also iterate over for all the superclasses. For interface return all
* the extended interfaces as well as superinterfaces for those extended interfaces.
*
* @param type type whose implemented or super interfaces are sought.
* @param configuration the current configuration of the doclet.
* @param sort if true, return list of interfaces sorted alphabetically.
* @return List of all the required interfaces.
*/
public static List<Type> getAllInterfaces(Type type, Configuration configuration, boolean sort) {
Map<ClassDoc, Type> results =
sort ? new TreeMap<ClassDoc, Type>() : new LinkedHashMap<ClassDoc, Type>();
Type[] interfaceTypes = null;
Type superType = null;
if (type instanceof ParameterizedType) {
interfaceTypes = ((ParameterizedType) type).interfaceTypes();
superType = ((ParameterizedType) type).superclassType();
} else if (type instanceof ClassDoc) {
interfaceTypes = ((ClassDoc) type).interfaceTypes();
superType = ((ClassDoc) type).superclassType();
} else {
interfaceTypes = type.asClassDoc().interfaceTypes();
superType = type.asClassDoc().superclassType();
}
for (int i = 0; i < interfaceTypes.length; i++) {
Type interfaceType = interfaceTypes[i];
ClassDoc interfaceClassDoc = interfaceType.asClassDoc();
if (!(interfaceClassDoc.isPublic()
|| (configuration == null || isLinkable(interfaceClassDoc, configuration)))) {
continue;
}
results.put(interfaceClassDoc, interfaceType);
List<Type> superInterfaces = getAllInterfaces(interfaceType, configuration, sort);
for (Iterator<Type> iter = superInterfaces.iterator(); iter.hasNext(); ) {
Type t = iter.next();
results.put(t.asClassDoc(), t);
}
}
if (superType == null) return new ArrayList<Type>(results.values());
// Try walking the tree.
addAllInterfaceTypes(
results,
superType,
superType instanceof ClassDoc
? ((ClassDoc) superType).interfaceTypes()
: ((ParameterizedType) superType).interfaceTypes(),
false,
configuration);
List<Type> resultsList = new ArrayList<Type>(results.values());
if (sort) {
Collections.sort(resultsList, new TypeComparator());
}
return resultsList;
}
/**
* Add the member summary for the given class.
*
* @param classDoc the class that is being documented
* @param member the member being documented
* @param firstSentenceTags the first sentence tags to be added to the summary
* @param tableContents the list of contents to which the documentation will be added
* @param counter the counter for determining id and style for the table row
*/
public void addMemberSummary(
ClassDoc classDoc,
ProgramElementDoc member,
Tag[] firstSentenceTags,
List<Content> tableContents,
int counter) {
HtmlTree tdSummaryType = new HtmlTree(HtmlTag.TD);
tdSummaryType.addStyle(HtmlStyle.colFirst);
writer.addSummaryType(this, member, tdSummaryType);
HtmlTree tdSummary = new HtmlTree(HtmlTag.TD);
setSummaryColumnStyle(tdSummary);
addSummaryLink(classDoc, member, tdSummary);
writer.addSummaryLinkComment(this, member, firstSentenceTags, tdSummary);
HtmlTree tr = HtmlTree.TR(tdSummaryType);
tr.addContent(tdSummary);
if (member instanceof MethodDoc && !member.isAnnotationTypeElement()) {
int methodType =
(member.isStatic()) ? MethodTypes.STATIC.value() : MethodTypes.INSTANCE.value();
if (member.containingClass().isInterface()) {
methodType =
(((MethodDoc) member).isAbstract())
? methodType | MethodTypes.ABSTRACT.value()
: methodType | MethodTypes.DEFAULT.value();
} else {
methodType =
(((MethodDoc) member).isAbstract())
? methodType | MethodTypes.ABSTRACT.value()
: methodType | MethodTypes.CONCRETE.value();
}
if (utils.isDeprecated(member) || utils.isDeprecated(classdoc)) {
methodType = methodType | MethodTypes.DEPRECATED.value();
}
methodTypesOr = methodTypesOr | methodType;
String tableId = "i" + counter;
typeMap.put(tableId, methodType);
tr.addAttr(HtmlAttr.ID, tableId);
}
if (counter % 2 == 0) tr.addStyle(HtmlStyle.altColor);
else tr.addStyle(HtmlStyle.rowColor);
tableContents.add(tr);
}
