/**
* Build the summaries for the methods that belong to the given class.
*
* @param node the XML element that specifies which components to document
* @param classContentTree content tree to which the documentation will be added
*/
public void buildSerializableMethods(XMLNode node, Content classContentTree) {
Content serializableMethodTree = methodWriter.getSerializableMethodsHeader();
MemberDoc[] members = currentClass.serializationMethods();
int membersLength = members.length;
if (membersLength > 0) {
for (int i = 0; i < membersLength; i++) {
currentMember = members[i];
Content methodsContentTree = methodWriter.getMethodsContentHeader((i == membersLength - 1));
buildChildren(node, methodsContentTree);
serializableMethodTree.addContent(methodsContentTree);
}
}
if (currentClass.serializationMethods().length > 0) {
classContentTree.addContent(
methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"), serializableMethodTree));
if (currentClass.isSerializable() && !currentClass.isExternalizable()) {
if (currentClass.serializationMethods().length == 0) {
Content noCustomizationMsg =
methodWriter.getNoCustomizationMsg(
configuration.getText("doclet.Serializable_no_customization"));
classContentTree.addContent(
methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"), noCustomizationMsg));
}
}
}
}
/**
* Build the class serialized form.
*
* @param node the XML element that specifies which components to document
* @param packageSerializedTree content tree to which the documentation will be added
*/
public void buildClassSerializedForm(XMLNode node, Content packageSerializedTree) {
Content classSerializedTree = writer.getClassSerializedHeader();
ClassDoc[] classes = currentPackage.allClasses(false);
Arrays.sort(classes);
for (int j = 0; j < classes.length; j++) {
currentClass = classes[j];
fieldWriter = writer.getSerialFieldWriter(currentClass);
methodWriter = writer.getSerialMethodWriter(currentClass);
if (currentClass.isClass() && currentClass.isSerializable()) {
if (!serialClassInclude(currentClass)) {
continue;
}
Content classTree = writer.getClassHeader(currentClass);
buildChildren(node, classTree);
classSerializedTree.addContent(classTree);
}
}
packageSerializedTree.addContent(classSerializedTree);
}
/**
* Return true if the given ClassDoc should be included in the serialized form.
*
* @param cd the ClassDoc object to check for serializability.
*/
private static boolean serialClassInclude(ClassDoc cd) {
if (cd.isEnum()) {
return false;
}
try {
cd.superclassType();
} catch (NullPointerException e) {
// Workaround for null pointer bug in ClassDoc.superclassType().
return false;
}
if (cd.isSerializable()) {
if (cd.tags("serial").length > 0) {
return serialDocInclude(cd);
} else if (cd.isPublic() || cd.isProtected()) {
return true;
} else {
return false;
}
}
return false;
}
/**
* Parses the data for a class type definition
*
* @param docClass
* @return
*/
protected static Class ParseClass(ClassDoc docClass) {
assert (docClass != null);
Class xmlClass = new Class();
// illegal use of this class.
assert (xmlClass != null);
xmlClass.name = docClass.name();
xmlClass.qualifiedName = docClass.qualifiedName();
xmlClass.isSerializable = docClass.isSerializable();
xmlClass.isExternalizable = docClass.isExternalizable();
xmlClass.isAbstract = docClass.isAbstract();
xmlClass.isException = docClass.isException();
xmlClass.isError = docClass.isError();
xmlClass.comment = docClass.commentText();
xmlClass.scope = DetermineScope(docClass);
xmlClass.isIncluded = docClass.isIncluded();
xmlClass.typeVariables =
ParseTypeVariables(docClass.typeParameters(), docClass.typeParamTags());
Type superClassType = docClass.superclassType();
if (superClassType != null) {
xmlClass.superClass = ParseType(superClassType);
}
Type[] interfaces = docClass.interfaceTypes();
ArrayList<TypeInfo> interfaceTypeNames = new ArrayList<TypeInfo>();
if (interfaces != null && interfaces.length > 0) {
for (Type interfaceType : interfaces) {
interfaceTypeNames.add(ParseType(interfaceType));
}
xmlClass.interfaces = interfaceTypeNames.toArray(new TypeInfo[] {});
}
ConstructorDoc[] constructors = docClass.constructors();
if (constructors != null && constructors.length > 0) {
ArrayList<Constructor> constructorList = new ArrayList<Constructor>();
for (ConstructorDoc constructor : constructors) {
constructorList.add(ParseConstructor(constructor));
}
xmlClass.constructors = constructorList.toArray(new Constructor[] {});
} else {
log.debug("No constructors in class: " + docClass.name());
}
MethodDoc[] methods = docClass.methods();
if (methods != null && methods.length > 0) {
ArrayList<Method> methodList = new ArrayList<Method>();
for (MethodDoc method : methods) {
methodList.add(ParseMethod(method));
}
xmlClass.methods = methodList.toArray(new Method[] {});
} else {
log.debug("No methods in class: " + docClass.name());
}
FieldDoc[] fields = docClass.fields();
if (fields != null && fields.length > 0) {
ArrayList<Field> fieldList = new ArrayList<Field>();
for (FieldDoc field : fields) {
fieldList.add(ParseField(field));
}
xmlClass.fields = fieldList.toArray(new Field[] {});
}
xmlClass.annotationInstances =
ParseAnnotationInstances(docClass.annotations(), docClass.qualifiedName());
return xmlClass;
}