/** {@inheritDoc} */ public void inherit(DocFinder.Input input, DocFinder.Output output) { ClassDoc exception; if (input.tagId == null) { ThrowsTag throwsTag = (ThrowsTag) input.tag; exception = throwsTag.exception(); input.tagId = exception == null ? throwsTag.exceptionName() : throwsTag.exception().qualifiedName(); } else { exception = input.method.containingClass().findClass(input.tagId); } ThrowsTag[] tags = input.method.throwsTags(); for (int i = 0; i < tags.length; i++) { if (input.tagId.equals(tags[i].exceptionName()) || (tags[i].exception() != null && (input.tagId.equals(tags[i].exception().qualifiedName())))) { output.holder = input.method; output.holderTag = tags[i]; output.inlineTags = input.isFirstSentence ? tags[i].firstSentenceTags() : tags[i].inlineTags(); output.tagList.add(tags[i]); } else if (exception != null && tags[i].exception() != null && tags[i].exception().subclassOf(exception)) { output.tagList.add(tags[i]); } } }
/** {@inheritDoc} */ public Content throwsTagOutput(ThrowsTag throwsTag) { ContentBuilder body = new ContentBuilder(); Content excName = (throwsTag.exceptionType() == null) ? new RawHtml(throwsTag.exceptionName()) : htmlWriter.getLink( new LinkInfoImpl( configuration, LinkInfoImpl.Kind.MEMBER, throwsTag.exceptionType())); body.addContent(HtmlTree.CODE(excName)); Content desc = htmlWriter.commentTagsToContent(throwsTag, null, throwsTag.inlineTags(), false); if (desc != null && !desc.isEmpty()) { body.addContent(" - "); body.addContent(desc); } HtmlTree result = HtmlTree.DD(body); return result; }
/** * Given an array of <code>Tag</code>s representing this custom tag, return its string * representation. * * @param throwTags the array of <code>ThrowsTag</code>s to convert. * @param writer the TagletWriter that will write this tag. * @param alreadyDocumented the set of exceptions that have already been documented. * @param allowDups True if we allow duplicate throws tags to be documented. * @return the TagletOutput representation of this <code>Tag</code>. */ protected TagletOutput throwsTagsOutput( ThrowsTag[] throwTags, TagletWriter writer, Set<String> alreadyDocumented, boolean allowDups) { TagletOutput result = writer.getOutputInstance(); if (throwTags.length > 0) { for (int i = 0; i < throwTags.length; ++i) { ThrowsTag tt = throwTags[i]; ClassDoc cd = tt.exception(); if ((!allowDups) && (alreadyDocumented.contains(tt.exceptionName()) || (cd != null && alreadyDocumented.contains(cd.qualifiedName())))) { continue; } if (alreadyDocumented.size() == 0) { result.appendOutput(writer.getThrowsHeader()); } result.appendOutput(writer.throwsTagOutput(tt)); alreadyDocumented.add(cd != null ? cd.qualifiedName() : tt.exceptionName()); } } return result; }
/** * Parses a method type definition * * @param docMethod * @return */ protected static Method ParseMethod(MethodDoc docMethod) { assert (docMethod != null); Method xmlMethod = new Method(); xmlMethod.name = docMethod.name(); xmlMethod.hash = computeHash(docMethod.qualifiedName(), docMethod.signature()); xmlMethod.qualifiedName = docMethod.qualifiedName(); xmlMethod.comment = docMethod.commentText(); xmlMethod.signature = docMethod.signature(); xmlMethod.isNative = docMethod.isNative(); xmlMethod.isVarArgs = docMethod.isVarArgs(); xmlMethod.isSynchronized = docMethod.isSynchronized(); xmlMethod.isFinal = docMethod.isFinal(); xmlMethod.isAbstract = docMethod.isAbstract(); xmlMethod.isStatic = docMethod.isStatic(); xmlMethod.scope = DetermineScope(docMethod); // Parse parameters of the method Parameter[] parameters = docMethod.parameters(); if (parameters != null && parameters.length > 0) { ParamTag[] paramComments = docMethod.paramTags(); ArrayList<Param> paramList = new ArrayList<Param>(); for (Parameter parameter : parameters) { ParamTag paramComment = null; // look to see if this parameter has comments // if so, paramComment will be set for (ParamTag testParam : paramComments) { String testParamName = testParam.parameterName(); if (testParamName != null) { if (testParamName.compareTo(parameter.name()) == 0) { paramComment = testParam; break; } } } paramList.add(ParseParameter(parameter, paramComment)); } xmlMethod.parameters = paramList.toArray(new Param[] {}); } else { log.debug("No parameters for method: " + docMethod.name()); } // Parse result data Result returnInfo = new Result(); Tag[] returnTags = docMethod.tags("@return"); if (returnTags != null && returnTags.length > 0) { // there should be only one return tag. but heck, // if they specify two, so what... StringBuilder builder = new StringBuilder(); for (Tag returnTag : returnTags) { String returnTagText = returnTag.text(); if (returnTagText != null) { builder.append(returnTagText); builder.append("\n"); } } returnInfo.comment = builder.substring(0, builder.length() - 1); } returnInfo.type = ParseType(docMethod.returnType()); xmlMethod.result = returnInfo; // Parse exceptions of the method Type[] types = docMethod.thrownExceptionTypes(); ThrowsTag[] exceptionComments = docMethod.throwsTags(); if (types != null && types.length > 0) { ArrayList<ExceptionInstance> exceptionList = new ArrayList<ExceptionInstance>(); for (Type exceptionType : types) { ExceptionInstance exception = new ExceptionInstance(); exception.type = ParseType(exceptionType); for (ThrowsTag exceptionComment : exceptionComments) { if (exceptionType == exceptionComment.exceptionType()) { exception.comment = exceptionComment.exceptionComment(); ClassDoc exceptionDetails = exceptionComment.exception(); // not yet parsing Exceptions defined within the supplied code set exception.type = ParseType(exceptionComment.exceptionType()); break; } } exceptionList.add(exception); } xmlMethod.exceptions = exceptionList.toArray(new ExceptionInstance[] {}); } // parse annotations from the method xmlMethod.annotationInstances = ParseAnnotationInstances(docMethod.annotations(), docMethod.qualifiedName()); return xmlMethod; }