private static List<MethodInspect> getInspects(ExecutableMemberDoc[] memberDocs) { List<MethodInspect> methodInspects = new ArrayList<>(memberDocs.length); for (ExecutableMemberDoc memberDoc : memberDocs) { List<String> signature = new ArrayList<>(); for (Parameter parameter : memberDoc.parameters()) { signature.add(parameter.type().qualifiedTypeName() + " " + parameter.name()); } MethodInspect methodInspect = new MethodInspect(memberDoc.name(), memberDoc.getRawCommentText(), String.join(", ", signature)); methodInspects.add(methodInspect); } return methodInspects; } }
/** * Given an array of <code>ParamTag</code>s,return its string representation. * @param holder the member that holds the param tags. * @param writer the TagletWriter that will write this tag. * @return the TagletOutput representation of these <code>ParamTag</code>s. */ public TagletOutput getTagletOutput(Doc holder, TagletWriter writer) { if (holder instanceof ExecutableMemberDoc) { ExecutableMemberDoc member = (ExecutableMemberDoc) holder; TagletOutput output = getTagletOutput(false, member, writer, member.typeParameters(), member.typeParamTags()); output.appendOutput(getTagletOutput(true, member, writer, member.parameters(), member.paramTags())); return output; } else { ClassDoc classDoc = (ClassDoc) holder; return getTagletOutput(false, classDoc, writer, classDoc.typeParameters(), classDoc.typeParamTags()); } }
Parameter[] params = em.parameters(); boolean isConstructor = em.isConstructor(); List<Type> classArgs = new ArrayList<Type>(); for (int k = 0; k < params.length; k++) { params[k], em); ClassDoc[] thr = em.thrownExceptions(); for (int k = 0; k < thr.length; k++) { add(isConstructor? classToConstructorThrows : classToMethodThrows,
private static String parameterListForFragmentIdentifier(ExecutableMemberDoc executableMemberDoc) { StringBuilder result = new StringBuilder().append('('); for (int i = 0; i < executableMemberDoc.parameters().length; i++) { Parameter parameter = executableMemberDoc.parameters()[i]; if (i > 0) result.append(", "); result.append(parameter.type().qualifiedTypeName()); } return result.append(')').toString(); }
/** * For backward compatibility, include an anchor using the erasures of the * parameters. NOTE: We won't need this method anymore after we fix * see tags so that they use the type instead of the erasure. * * @param emd the ExecutableMemberDoc to anchor to. * @return the 1.4.x style anchor for the ExecutableMemberDoc. */ protected String getErasureAnchor(ExecutableMemberDoc emd) { StringBuffer buf = new StringBuffer(emd.name() + "("); Parameter[] params = emd.parameters(); boolean foundTypeVariable = false; for (int i = 0; i < params.length; i++) { if (i > 0) { buf.append(","); } Type t = params[i].type(); foundTypeVariable = foundTypeVariable || t.asTypeVariable() != null; buf.append(t.isPrimitive() ? t.typeName() : t.asClassDoc().qualifiedName()); buf.append(t.dimension()); } buf.append(")"); return foundTypeVariable ? buf.toString() : null; } }
protected void writeParameters(ExecutableMemberDoc member, boolean includeAnnotations) { print('('); Parameter[] params = member.parameters(); String indent = makeSpace(writer.displayLength); if (configuration().linksource) { indent+= makeSpace(member.name().length()); (paramstart == params.length - 1) && member.isVarArgs()); break; writeParam(member, params[i], (i == params.length - 1) && member.isVarArgs());
htmltree.addContent("("); String sep = ""; Parameter[] params = member.parameters(); String indent = makeSpace(indentSize + 1); Type rcvrType = member.receiverType(); if (includeAnnotations && rcvrType instanceof AnnotatedType) { AnnotationDesc[] descList = rcvrType.asAnnotatedType().annotations(); (paramstart == params.length - 1) && member.isVarArgs(), htmltree); break; addParam(member, params[i], (i == params.length - 1) && member.isVarArgs(), htmltree);
/** * {@inheritDoc} */ protected Content getDeprecatedLink(ProgramElementDoc member) { ExecutableMemberDoc emd = (ExecutableMemberDoc)member; return writer.getDocLink(LinkInfoImpl.Kind.MEMBER, (MemberDoc) emd, emd.qualifiedName() + emd.flatSignature()); }
/** * {@inheritDoc} */ public Content getTagletOutput(Doc holder, TagletWriter writer) { ExecutableMemberDoc execHolder = (ExecutableMemberDoc) holder; ThrowsTag[] tags = execHolder.throwsTags(); Content result = writer.getOutputInstance(); HashSet<String> alreadyDocumented = new HashSet<String>(); if (tags.length > 0) { result.addContent(throwsTagsOutput( execHolder.throwsTags(), writer, alreadyDocumented, true)); } result.addContent(inheritThrowsDocumentation(holder, execHolder.thrownExceptionTypes(), alreadyDocumented, writer)); result.addContent(linkToUndocumentedDeclaredExceptions( execHolder.thrownExceptionTypes(), alreadyDocumented, writer)); return result; }
public String getAnchor(ExecutableMemberDoc emd, boolean isProperty) { if (isProperty) { return emd.name(); } StringBuilder signature = new StringBuilder(emd.signature()); StringBuilder signatureParsed = new StringBuilder(); int counter = 0; for (int i = 0; i < signature.length(); i++) { char c = signature.charAt(i); if (c == '<') { counter++; } else if (c == '>') { counter--; } else if (counter == 0) { signatureParsed.append(c); } } return emd.name() + signatureParsed.toString(); }
/** * Prints the exception documentation. * * @param pw the writer to print the exception documentation to * @param memberDoc the member to document the exceptions for */ private static void printThrowsTags(PrintWriter pw, ExecutableMemberDoc memberDoc) { ThrowsTag[] throwsTags = memberDoc.throwsTags(); for (ThrowsTag throwsTag : throwsTags) { ClassDoc exceptionDoc = throwsTag.exception(); if (exceptionDoc == null) { ERROR_REPORTER.printWarning("Unable to locate class '" + throwsTag.exceptionName() + "' for '" + memberDoc.qualifiedName() + "'"); continue; } printIndent(pw, 3); pw.print("<exception cref=\""); printReference(pw, exceptionDoc, true); pw.print("\">"); printComment(pw, memberDoc, throwsTag.inlineTags()); pw.println("</exception>"); } }
private static String commentForParameter(ExecutableMemberDoc method, com.sun.javadoc.Parameter parameter) { for (ParamTag tag : method.paramTags()) { if (tag.parameterName().equals(parameter.name())) { return tag.parameterComment(); } } return ""; }
protected void writeExceptions(ExecutableMemberDoc member) { Type[] exceptions = member.thrownExceptionTypes(); if(exceptions.length > 0) { LinkInfoImpl memberTypeParam = new LinkInfoImpl( LinkInfoImpl.CONTEXT_MEMBER, member, false); int retlen = getReturnTypeLength(member); writer.getTypeParameterLinks(memberTypeParam); retlen += memberTypeParam.displayLength == 0 ? 0 : memberTypeParam.displayLength + 1; String indent = makeSpace(modifierString(member).length() + member.name().length() + retlen - 4); writer.println(); writer.print(indent); writer.print("throws "); indent += " "; writer.printLink(new LinkInfoImpl( LinkInfoImpl.CONTEXT_MEMBER, exceptions[0])); for(int i = 1; i < exceptions.length; i++) { writer.println(","); writer.print(indent); writer.printLink(new LinkInfoImpl( LinkInfoImpl.CONTEXT_MEMBER, exceptions[i])); } } }
/** * Return the key to the member map for the given member. */ private Object getMemberKey(ProgramElementDoc doc) { if (doc.isConstructor()) { return doc.name() + ((ExecutableMemberDoc)doc).signature(); } else if (doc.isMethod()) { return getClassMember((MethodDoc) doc); } else if (doc.isField() || doc.isEnumConstant() || doc.isAnnotationTypeElement()) { return doc.name(); } else { // it's a class or interface String classOrIntName = doc.name(); //Strip off the containing class name because we only want the member name. classOrIntName = classOrIntName.indexOf('.') != 0 ? classOrIntName.substring(classOrIntName.lastIndexOf('.'), classOrIntName.length()) : classOrIntName; return "clint" + classOrIntName; } } }
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) { ExecutableMemberDoc emd = (ExecutableMemberDoc)member; String name = emd.name(); writer.strong(); writer.printDocLink(context, cd, (MemberDoc) emd, name, false); writer.strongEnd(); writer.displayLength = name.length(); writeParameters(emd, false); }
/** * Prints the return documentation. * * @param pw the writer to print the return documentation to * @param memberDoc the member to document the return for */ private static void printReturnTag(PrintWriter pw, ExecutableMemberDoc memberDoc) { Tag[] returnDoc = memberDoc.tags("@return"); if (returnDoc.length == 1) { printIndent(pw, 3); pw.print("<returns>"); printComment(pw, memberDoc, returnDoc[0].inlineTags()); pw.println("</returns>"); } else if (returnDoc.length > 1) { ERROR_REPORTER.printWarning("More than one return tag specified for '" + memberDoc.qualifiedName() + "'"); } }
protected void writeSignature(ExecutableMemberDoc member) { writer.displayLength = 0; writer.pre(); writer.writeAnnotationInfo(member); printModifiers(member); writeTypeParameters(member); if (configuration().linksource && member.position().line() != classdoc.position().line()) { writer.printSrcLink(member, member.name()); } else { strong(member.name()); } writeParameters(member); writeExceptions(member); writer.preEnd(); }
/** * Generate Description for Class, Field, Method or Constructor. * for Java.* Packages Class Members. * * @param member MemberDoc for the member of the Class Kind. * @see com.sun.javadoc.MemberDoc */ protected void printDescription(MemberDoc member) { String name = (member instanceof ExecutableMemberDoc)? member.name() + ((ExecutableMemberDoc)member).flatSignature() : member.name(); if (name.indexOf("<") != -1 || name.indexOf(">") != -1) { name = Util.escapeHtmlChars(name); } ClassDoc containing = member.containingClass(); dt(); printDocLink(LinkInfoImpl.CONTEXT_INDEX, member, name, true); println(" - "); printMemberDesc(member); println(); dtEnd(); dd(); printComment(member); ddEnd(); println(); }
/** * Given an array of <code>ParamTag</code>s,return its string representation. * @param holder the member that holds the param tags. * @param writer the TagletWriter that will write this tag. * @return the TagletOutput representation of these <code>ParamTag</code>s. */ public Content getTagletOutput(Doc holder, TagletWriter writer) { if (holder instanceof ExecutableMemberDoc) { ExecutableMemberDoc member = (ExecutableMemberDoc) holder; Content output = getTagletOutput(false, member, writer, member.typeParameters(), member.typeParamTags()); output.addContent(getTagletOutput(true, member, writer, member.parameters(), member.paramTags())); return output; } else { ClassDoc classDoc = (ClassDoc) holder; return getTagletOutput(false, classDoc, writer, classDoc.typeParameters(), classDoc.typeParamTags()); } }
Parameter[] params = em.parameters(); boolean isConstructor = em.isConstructor(); List<Type> classArgs = new ArrayList<Type>(); for (int k = 0; k < params.length; k++) { params[k], em); ClassDoc[] thr = em.thrownExceptions(); for (int k = 0; k < thr.length; k++) { add(isConstructor? classToConstructorThrows : classToMethodThrows,