/** * Check to see if overview details should be printed. If * nocomment option set or if there is no text to be printed * for deprecation info, comment or tags, do not print overview details. * * @param field the field to check overview details for. * @return true if overview details need to be printed */ public boolean shouldPrintOverview(FieldDoc field) { if (!configuration.nocomment) { if(!field.commentText().isEmpty() || writer.hasSerializationOverviewTags(field)) return true; } if (field.tags("deprecated").length > 0) return true; return false; } }
... private Content getValue(FieldDoc member) { Content valueContent; if ("char".equals(member.type().toString())) { valueContent = new StringContent("'" + (char) ((Integer) member.constantValue()).intValue() + "'" ); } else { valueContent = new StringContent(member.constantValueExpression()); } Content code = HtmlTree.CODE(valueContent); return HtmlTree.TD(HtmlStyle.colLast, code); } ...
public class ExtractCommentsDoclet { public static boolean start(RootDoc root) throws IOException { for (ClassDoc c : root.classes()) { print(c.qualifiedName(), c.commentText()); for (FieldDoc f : c.fields(false)) { print(f.qualifiedName(), f.commentText()); } for (MethodDoc m : c.methods(false)) { print(m.qualifiedName(), m.commentText()); if (m.commentText() != null && m.commentText().length() > 0) { for (ParamTag p : m.paramTags()) print(m.qualifiedName() + "@" + p.parameterName(), p.parameterComment()); for (Tag t : m.tags("return")) { if (t.text() != null && t.text().length() > 0) print(m.qualifiedName() + "@return", t.text()); } } } } return true; } private static void print(String name, String comment) throws IOException { if (comment != null && comment.length() > 0) { new FileWriter(name + ".txt").append(comment).close(); } } }
/** * Build the serial UID information for the given class. */ public void buildSerialUIDInfo() { FieldDoc[] fields = currentClass.fields(false); for (int i = 0; i < fields.length; i++) { if (fields[i].name().equals("serialVersionUID") && fields[i].constantValueExpression() != null) { writer.writeSerialUIDInfo(SERIAL_VERSION_UID_HEADER, fields[i].constantValueExpression()); return; } } }
protected Field parseField(FieldDoc fieldDoc) { Field fieldNode = objectFactory.createField(); fieldNode.setType(parseTypeInfo(fieldDoc.type())); fieldNode.setName(fieldDoc.name()); fieldNode.setQualified(fieldDoc.qualifiedName()); String comment = fieldDoc.commentText(); if (comment.length() > 0) { fieldNode.setComment(comment); } fieldNode.setScope(parseScope(fieldDoc)); fieldNode.setFinal(fieldDoc.isFinal()); fieldNode.setStatic(fieldDoc.isStatic()); fieldNode.setVolatile(fieldDoc.isVolatile()); fieldNode.setTransient(fieldDoc.isTransient()); fieldNode.setConstant(fieldDoc.constantValueExpression()); for (AnnotationDesc annotationDesc : fieldDoc.annotations()) { fieldNode.getAnnotation().add(parseAnnotationDesc(annotationDesc, fieldDoc.qualifiedName())); } for (Tag tag : fieldDoc.tags()) { fieldNode.getTag().add(parseTag(tag)); } return fieldNode; }
private FieldDoc fieldForProperty(FieldDoc[] fields, MethodDoc property) { for (FieldDoc field : fields) { final String fieldName = field.name(); final String propertyName = fieldName + "Property"; if (propertyName.equals(property.name())) { return field; } } return null; }
result = factory.constructAttribute( fieldDoc.name() ); factory.constructTagDocumentation( result, fieldDoc.commentText() ); if ( fieldDoc.isPublic() ) { result.setVisibility( VisibilityKindEnum.VK_PUBLIC ); } else if ( fieldDoc.isPrivate() ) { result.setVisibility( VisibilityKindEnum.VK_PRIVATE ); } else if ( fieldDoc.isProtected() ) { result.setVisibility( VisibilityKindEnum.VK_PROTECTED ); if ( fieldDoc.isStatic() ) { result.setOwnerScope( ScopeKindEnum.SK_CLASSIFIER ); } else { if ( fieldDoc.isFinal() ) { result.setChangeability( ChangeableKindEnum.CK_FROZEN ); } else { typeDoc = fieldDoc.type(); assignTypeToAttribute( typeDoc, result ); initialValue = fieldDoc.constantValueExpression(); if ( initialValue != null && !initialValue.equals("") ) { initialValueExpression = factory.constructExpression( initialValue );
if (fd.isStatic()) continue; if (!fd.isPrivate()) continue; name = fd.name().replaceAll("^[$_]*", ""); ParameterDescription pd = new ParameterDescription(fd, name, fd.type().qualifiedTypeName(), get(values, "value", ""), get(values, "defaultPrefix", BindingConstants.PROP), getBoolean(values, "required", false), getBoolean(values, "allowNull", true), getBoolean(values, "cache", true),
private Type getType(MemberDoc member) { if (member instanceof FieldDoc) { return ((FieldDoc) member).type(); } else { return ((MethodDoc) member).returnType(); } } }
/** * Build the field information. * * @param node the XML element that specifies which components to document * @param fieldsContentTree content tree to which the documentation will be added */ public void buildFieldInfo(XMLNode node, Content fieldsContentTree) { if(configuration.nocomment){ return; } FieldDoc field = (FieldDoc)currentMember; ClassDoc cd = field.containingClass(); // Process default Serializable field. if ((field.tags("serial").length == 0) && ! field.isSynthetic() && configuration.serialwarn) { configuration.message.warning(field.position(), "doclet.MissingSerialTag", cd.qualifiedName(), field.name()); } fieldWriter.addMemberDescription(field, fieldsContentTree); fieldWriter.addMemberTags(field, fieldsContentTree); }
/** * Parses an enum type definition * * @param fieldDoc * @return */ protected EnumConstant parseEnumConstant(FieldDoc fieldDoc) { EnumConstant enumConstant = objectFactory.createEnumConstant(); enumConstant.setName(fieldDoc.name()); String comment = fieldDoc.commentText(); if (comment.length() > 0) { enumConstant.setComment(comment); } for (AnnotationDesc annotationDesc : fieldDoc.annotations()) { enumConstant.getAnnotation().add(parseAnnotationDesc(annotationDesc, fieldDoc.qualifiedName())); } for (Tag tag : fieldDoc.tags()) { enumConstant.getTag().add(parseTag(tag)); } return enumConstant; }
if (!fieldDoc.isTransient() && !fieldDoc.isStatic() && !hasAnnotation(fieldDoc, SchemaIgnore.class)) schemaFieldDoc.setFieldName(fieldDoc.name()); schemaFieldDoc.setFieldTitle(getTitle(fieldDoc)); String originalText = fieldDoc.commentText(); Tag[] originalInlineTags = fieldDoc.inlineTags(); if (fieldDocOverrides.containsKey(fieldDoc.name())) docForField.setRawCommentText(fieldDocOverrides.get(fieldDoc.name())); revertInlineTags = true; else if (Strings.isNullOrEmpty(fieldDoc.commentText())) fieldDoc.setRawCommentText(originalText); Class docImplClass = fieldDoc.getClass().getSuperclass().getSuperclass().getSuperclass(); Field inlineTagsField = docImplClass.getDeclaredField("inlineTags");
Object cv = ((FieldDoc) doc).constantValue(); if (cv == null) { rootDoc.printError( ec.name(), // label
/** * {@inheritDoc} */ public TagletOutput getTagletOutput(Tag tag, TagletWriter writer) { FieldDoc field = getFieldDoc( writer.configuration(), tag, tag.text()); if (field == null) { //Reference is unknown. writer.getMsgRetriever().warning(tag.holder().position(), "doclet.value_tag_invalid_reference", tag.text()); } else if (field.constantValue() != null) { return writer.valueTagOutput(field, Util.escapeHtmlChars(field.constantValueExpression()), ! field.equals(tag.holder())); } else { //Referenced field is not a constant. writer.getMsgRetriever().warning(tag.holder().position(), "doclet.value_tag_invalid_constant", field.name()); } return writer.getOutputInstance(); } }
/** * Helper routine that provides a FreeMarker map for an enumClass, grabbing the * values of the enum and their associated javadoc documentation. * * @param enumClass * @return */ @Requires("enumClass.isEnum()") private List<Map<String, Object>> docForEnumArgument(final Class enumClass) { final ClassDoc doc = this.getDoclet().getClassDocForClass(enumClass); if ( doc == null ) throw new RuntimeException("Tried to get docs for enum " + enumClass + " but got null instead"); final Set<String> enumConstantFieldNames = enumConstantsNames(enumClass); final List<Map<String, Object>> bindings = new ArrayList<Map<String, Object>>(); for (final FieldDoc fieldDoc : doc.fields(false)) { if (enumConstantFieldNames.contains(fieldDoc.name()) ) bindings.add( new HashMap<String, Object>() {{ put("name", fieldDoc.name()); put("summary", fieldDoc.commentText()); }}); } return bindings; }
protected static Field getFieldForFieldDoc(FieldDoc fieldDoc) { try { Class clazz = getClassForDoc(fieldDoc.containingClass()); return JVMUtils.findField(clazz, fieldDoc.name()); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } }
resultDoc.setType(fieldDoc.type().typeName()); addRefType(classDoc, DocletUtil.getFieldByDoc(resultClassDoc, fieldDoc).getGenericType() , resultDoc); String[] paramTexts = fieldDoc.commentText().split("(e.g|eg|e.g.|example|exam|例如|如)(:|:)", 2); resultDoc.setDesc(paramTexts[0]); resultDoc.setExampleValue(paramTexts.length==2 ? paramTexts[1] : "");
/** * Get the type column for the constant summary table row. * * @param member the field to be documented. * @return the type column of the constant table row */ private Content getTypeColumn(FieldDoc member) { Content anchor = getMarkerAnchor(currentClassDoc.qualifiedName() + "." + member.name()); Content tdType = HtmlTree.TD(HtmlStyle.colFirst, anchor); Content code = new HtmlTree(HtmlTag.CODE); StringTokenizer mods = new StringTokenizer(member.modifiers()); while(mods.hasMoreTokens()) { Content modifier = new StringContent(mods.nextToken()); code.addContent(modifier); code.addContent(getSpace()); } Content type = getLink(new LinkInfoImpl(configuration, LinkInfoImpl.Kind.CONSTANT_SUMMARY, member.type())); code.addContent(type); tdType.addContent(code); return tdType; }
private ParameterDescription getPublishedParameterDescription(ClassDescriptionSource source, FieldDoc fd, String name) { String currentClassName = fd.type().qualifiedTypeName(); while (true) { ClassDescription componentCD = source.getDescription(currentClassName); if (componentCD.classDoc == null) throw new IllegalArgumentException(String.format("Published parameter '%s' from %s not found.", name, fd.qualifiedName())); if (componentCD.parameters.containsKey(name)) { return componentCD.parameters.get(name); } currentClassName = componentCD.classDoc.superclass().typeName(); } }