com.sun.javadoc.Tag Java Examples

public String toString(Tag tag) {
	String[] splitted = split(tag);
	if (splitted == null)
		return "";
	File file = resolve(splitted[0], tag.position());
	String contents = null;
	if (file.exists()) {
		try {
			contents = Tools.readTextFile(file);
			contents = contents.replaceAll("<", "&lt;");
			contents = contents.replaceAll(">", "&gt;");
		} catch (IOException e) {
			contents = "Cannot read file '" + file + "': " + e;
			System.err.println(tag.position() + ": cannot read file '" + file + "'!");
		}
	} else {
		contents = "File '" + file + "' does not exist!";
		System.err.println(tag.position() + ": File '" + file + "' does not exist!");
	}
	return "<pre>" + contents + "</pre><br><center><i>Figure:</i> " + splitted[2] + "</center>";
}
 

/**
 * {@inheritDoc}
 */
@Override
public Content getTagletOutput(Doc doc, TagletWriter writer) throws IllegalArgumentException {
	Tag[] tags = doc.tags(getName());
	if (tags.length==0 && doc instanceof MethodDoc) { // inherit if necessary and possible
		final DocFinder.Output inheritedDoc = DocFinder.search(new DocFinder.Input((MethodDoc) doc, this));
		tags = inheritedDoc.holderTag == null ? tags : new Tag[] {inheritedDoc.holderTag};
	}
	if (tags.length==0)
		return null;
	final StringBuilder out = writeHeader(new StringBuilder());
	for(Tag tag : tags) { 
		writeTag(out, tag, writer);
	}
	return new RawHtml(out.toString());
}
 

/**
 * {@inheritDoc}
 * @see com.sun.tools.doclets.internal.toolkit.taglets.Taglet#getTagletOutput(com.sun.javadoc.Doc, com.sun.tools.doclets.internal.toolkit.taglets.TagletWriter)
 */
@Override
public TagletOutput getTagletOutput(Doc doc, TagletWriter writer) throws IllegalArgumentException {
	Tag[] tags = doc.tags(getName());
	if (tags.length==0 && doc instanceof MethodDoc) { // inherit if necessary and possible
		final DocFinder.Output inheritedDoc = DocFinder.search(new DocFinder.Input((MethodDoc) doc, this));
		tags = inheritedDoc.holderTag == null ? tags : new Tag[] {inheritedDoc.holderTag};
	}
	if (tags.length==0)
		return null;
	final StringBuilder out = writeHeader(new StringBuilder());
	for(Tag tag : tags) { 
		writeTag(out, tag, writer);
	}
	return new TagletOutputImpl(out.toString());
}
 

public static boolean start(final RootDoc root) {
    for (final ClassDoc cls : root.classes()) {
        final List<ProgramElementDoc> elements = new LinkedList<>();
        elements.add(cls);
        elements.addAll(Arrays.asList(cls.constructors()));
        elements.addAll(Arrays.asList(cls.methods()));
        for (final ProgramElementDoc elem : elements) {
            for (final Tag tag : elem.inlineTags()) {
                final String name = tag.name();
                if (name.equals("@code") && tag.text().trim().startsWith(">")) {
                    generateRunner(cls, elem, tag);
                }
            }
        }
    }
    return true;
}
 

/**
 * 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;
}
 

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;
}
 

@Override
public String toString(Tag[] tags) {
  if (tags.length == 0) {
    return null;
  }

  ClassDoc classDoc = (ClassDoc) tags[0].holder();

  return processExternalResources(classDoc) + processConfigurationParameters(classDoc);
}
 

/**
 * Default processing of any documentation node.
 *
 * @param doc              The documentation.
 * @param fixLeadingSpaces `true` if leading spaces should be fixed.
 *
 * @see Options#toHtml(String, boolean)
 */
protected void defaultProcess(Doc doc, boolean fixLeadingSpaces) {
    try {
        StringBuilder buf = new StringBuilder();
        buf.append(getOptions().toHtml(doc.commentText(), fixLeadingSpaces));
        buf.append('\n');
        for ( Tag tag : doc.tags() ) {
            processTag(tag, buf);
            buf.append('\n');
        }
        doc.setRawCommentText(buf.toString());
    }
    catch ( final ParserRuntimeException e ) {
        if ( doc instanceof RootDoc ) {
            printError(new SourcePosition() {
                @Override
                public File file() {
                    return options.getOverviewFile();
                }
                @Override
                public int line() {
                    return 0;
                }
                @Override
                public int column() {
                    return 0;
                }
            }, e.getMessage());
        }
        else {
            printError(doc.position(), e.getMessage());
        }
    }
}
 

public static FieldDocumentation fromFieldDoc(FieldDoc fieldDoc) {
    FieldDocumentation fd = new FieldDocumentation();
    fd.comment = fieldDoc.commentText();

    for (Tag tag : fieldDoc.tags()) {
        fd.tags.put(cleanupTagName(tag.name()), tag.text());
    }

    return fd;
}
 

public String toString(Tag[] tags) {
	if (tags.length == 0) {
		return null;
	}
	String result = "<dt><b>Bibliography:</b></dt><dd>";
	result += "<ul>";
	for (int i = 0; i < tags.length; i++) {
		String key = tags[i].text().trim();
		String entry = getBibEntry(key);
		result += "<li>" + ((entry != null) ? entry : key) + "</li>";
	}
	result += "</ul></dd>";
	return result;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void inherit(DocFinder.Input input, DocFinder.Output output) {
	if (input.element != null && input.element.isMethod()) {
		final Tag[] tags = input.element.tags(tagName);
		if (tags.length > 0) {
			output.holder = input.element;
			output.holderTag = tags[0];
			output.inlineTags = input.isFirstSentence ?
					tags[0].firstSentenceTags() : tags[0].inlineTags();
		} 
	} 
}
 

public static boolean start(RootDoc root) throws IOException {
    String dumpFileName = readOptions(root.options());
    OutputStream os = Files.newOutputStream(Paths.get(dumpFileName));
    Properties javaDocMap = new Properties();
    for (ClassDoc classDoc : root.classes()) {
        javaDocMap.put(classDoc.toString(), classDoc.commentText());
        for (MethodDoc method : classDoc.methods()) {
            javaDocMap.put(method.qualifiedName(), method.commentText());
            for (ParamTag paramTag : method.paramTags()) {
                Parameter[] parameters = method.parameters();
                for (int i = 0; i < parameters.length; ++i) {
                    if (parameters[i].name().equals(paramTag.parameterName())) {
                        javaDocMap.put(method.qualifiedName() + ".paramCommentTag." + i,
                               paramTag.parameterComment());
                    }
                }
            }
            Tag[] retTags = method.tags("return");
            if (retTags != null && retTags.length == 1) {
                Tag retTag = method.tags("return")[0];
                javaDocMap.put(method.qualifiedName() + "." + "returnCommentTag",
                               retTag.text());
            }
        }

    }
    javaDocMap.store(os, "");
    os.flush();
    os.close();
    return true;
}
 

protected Package parsePackage(PackageDoc packageDoc) {
	Package packageNode = objectFactory.createPackage();
	packageNode.setName(packageDoc.name());
	String comment = packageDoc.commentText();
	if (comment.length() > 0) {
		packageNode.setComment(comment);
	}

	for (Tag tag : packageDoc.tags()) {
		packageNode.getTag().add(parseTag(tag));
	}

	return packageNode;
}
 

public String toString(final Tag[] tags) {
    if (tags.length == 0) {
        return null;
    }

    StringBuilder buf = new StringBuilder(String.format("\n<dl><dt><span class=\"strong\">%s</span></dt>\n", getHeader()));
    for (Tag t : tags) {
        buf.append("   <dd>").append(genLink(t.text())).append("</dd>\n");
    }
    return buf.toString();
}
 

/**
 * Process a tag.
 *
 * @param tag      The tag.
 * @param target   The target string builder.
 */
@SuppressWarnings("unchecked")
protected void processTag(Tag tag, StringBuilder target) {
    TagRenderer<Tag> renderer = (TagRenderer<Tag>)tagRenderers.get(tag.kind());
    if ( renderer == null ) {
        renderer = TagRenderer.VERBATIM;
    }
    renderer.render(tag, target, this);
}
 

public String toTex(Tag tag) {
	String[] splitted = split(tag);
	if (splitted == null)
		return "";
	File file = resolve(splitted[0], tag.position());
	if (!file.exists()) {
		System.err.println(tag.position() + ": File '" + file + "' does not exist!");
		return "";
	} else {
		return "\\examplefile{" + file.getAbsolutePath() + "}{" + splitted[1] + "}{" + splitted[2] + "}";
	}
}
 

@Override
public String toString(Tag tag) {
  Tag[] tags = new Tag[1];
  tags[0] = tag;

  return toString(tags);
}
 

public static MethodDocumentation fromMethodDoc(MethodDoc methodDoc) {
    MethodDocumentation md = new MethodDocumentation();
    md.comment = methodDoc.commentText();

    for (Tag tag : methodDoc.tags()) {
        if (tag instanceof ParamTag) {
            ParamTag paramTag = (ParamTag) tag;
            md.parameters.put(paramTag.parameterName(), paramTag.parameterComment());
        } else {
            md.tags.put(cleanupTagName(tag.name()), tag.text());
        }
    }

    return md;
}
 

/**
 * Appends the formatted definition tag to the given buffer.
 * @return out
 */
private StringBuilder writeTag(StringBuilder out, Tag tag, TagletWriter writer) {
	return out.append(DocletConstants.NL)
			.append("<DD><CODE>")
			.append(writer.commentTagsToOutput(tag, null, tag.inlineTags(), false))
			.append("</CODE></DD>");
}
 

/**
 * {@inheritDoc}
 * @see com.sun.tools.doclets.internal.toolkit.taglets.InheritableTaglet#inherit(com.sun.tools.doclets.internal.toolkit.util.DocFinder.Input, com.sun.tools.doclets.internal.toolkit.util.DocFinder.Output)
 */
@Override
public void inherit(Input input, Output output) {
	if (input.method != null) {
		final Tag[] tags = input.method.tags(tagName);
		if (tags.length > 0) {
			output.holder = input.method;
			output.holderTag = tags[0];
			output.inlineTags = input.isFirstSentence ?
					tags[0].firstSentenceTags() : tags[0].inlineTags();
		} 
	} 
}
 

private PSOperatorDoc(ClassDoc classDoc, MethodDoc methodDoc) {
        this.declaringClassDoc = classDoc;
        this.methodDoc = methodDoc;
        this.description = methodDoc.commentText().replace('\n', ' ');
        this.paramDesc = "";

        Tag[] paramTags = methodDoc.tags("param");
        for (Tag paramTag : paramTags) {
            String paraStr = paramTag.text();
            String paraName = paraStr.substring(0, paraStr.indexOf(' ')).replace('\n', ' ');;
            String paraDesc = paraStr.substring(paraStr.indexOf(' ') + 1).replace('\n', ' ');;
            this.paramDesc += "<br> - `" + paraName + "`: " + paraDesc;
        }

        this.returnType = methodDoc.returnType();
//        ParameterizedType returnType = methodDoc.returnType().asParameterizedType();
//        this.inputType = returnType.typeArguments()[0];
//        this.outputType = returnType.typeArguments()[1];
//        this.completeSignature = "Function<" + this.inputType + ", " + this.outputType + "> " + methodDoc.toString();

        String shortSignature = classDoc.name() + "." + methodDoc.name() + "(";
        boolean firstParameter = true;
        for (Parameter parameter : methodDoc.parameters()) {
            if (firstParameter) {
                shortSignature += Utils.getSimpleTypeName(parameter.type()) + " " + parameter.name();
                firstParameter = false;
            } else {
                shortSignature += ", " + Utils.getSimpleTypeName(parameter.type()) + " " + parameter.name();
            }
        }
        shortSignature += ")";
        this.shortSignature = shortSignature;
    }
 

protected Constructor parseConstructor(ConstructorDoc constructorDoc) {
	Constructor constructorNode = objectFactory.createConstructor();

	constructorNode.setName(constructorDoc.name());
	constructorNode.setQualified(constructorDoc.qualifiedName());
	String comment = constructorDoc.commentText();
	if (comment.length() > 0) {
		constructorNode.setComment(comment);
	}
	constructorNode.setScope(parseScope(constructorDoc));
	constructorNode.setIncluded(constructorDoc.isIncluded());
	constructorNode.setFinal(constructorDoc.isFinal());
	constructorNode.setNative(constructorDoc.isNative());
	constructorNode.setStatic(constructorDoc.isStatic());
	constructorNode.setSynchronized(constructorDoc.isSynchronized());
	constructorNode.setVarArgs(constructorDoc.isVarArgs());
	constructorNode.setSignature(constructorDoc.signature());

	for (Parameter parameter : constructorDoc.parameters()) {
		constructorNode.getParameter().add(parseMethodParameter(parameter));
	}

	for (Type exceptionType : constructorDoc.thrownExceptionTypes()) {
		constructorNode.getException().add(parseTypeInfo(exceptionType));
	}

	for (AnnotationDesc annotationDesc : constructorDoc.annotations()) {
		constructorNode.getAnnotation().add(parseAnnotationDesc(annotationDesc, constructorDoc.qualifiedName()));
	}

	for (Tag tag : constructorDoc.tags()) {
		constructorNode.getTag().add(parseTag(tag));
	}

	return constructorNode;
}
 

protected Interface parseInterface(ClassDoc classDoc) {

		Interface interfaceNode = objectFactory.createInterface();
		interfaceNode.setName(classDoc.name());
		interfaceNode.setQualified(classDoc.qualifiedName());
		String comment = classDoc.commentText();
		if (comment.length() > 0) {
			interfaceNode.setComment(comment);
		}
		interfaceNode.setIncluded(classDoc.isIncluded());
		interfaceNode.setScope(parseScope(classDoc));

		for (TypeVariable typeVariable : classDoc.typeParameters()) {
			interfaceNode.getGeneric().add(parseTypeParameter(typeVariable));
		}

		for (Type interfaceType : classDoc.interfaceTypes()) {
			interfaceNode.getInterface().add(parseTypeInfo(interfaceType));
		}

		for (MethodDoc method : classDoc.methods()) {
			interfaceNode.getMethod().add(parseMethod(method));
		}

		for (AnnotationDesc annotationDesc : classDoc.annotations()) {
			interfaceNode.getAnnotation().add(parseAnnotationDesc(annotationDesc, classDoc.qualifiedName()));
		}

		for (Tag tag : classDoc.tags()) {
			interfaceNode.getTag().add(parseTag(tag));
		}

		for (FieldDoc field : classDoc.fields()) {
			interfaceNode.getField().add(parseField(field));
		}

		return interfaceNode;
	}
 

private String[] split(Tag tag) {
	String[] result = tag.text().split("\\|");
	if (result.length != 3) {
		System.err.println("Usage: {@" + getName() + " filename|label|caption} (was: " + tag.text() + ") (" + tag.position() + ")");
		return null;
	}
	return result;
}
 

@Override
public Tag[] tags(String tagname) {
    return delegate.tags(tagname);
}
 

public String toTex(Tag tag) {
	return "\\cite{" + tag.text() + "}";
}
 

public String toTex(Tag[] tag) {
	return null;
}
 

@Override
public Tag[] tags() {
	return this.delegate.tags();
}
 

@Override
public Tag[] tags(String arg0) {
	return this.delegate.tags(arg0);
}
 

@Override
public Tag[] tags(String arg0) {
	return this.delegate.tags(arg0);
}