• Home
• dev.gradleplugins
• gradle-api
• 3.1
• source code
• StandardJavadocDocletOptions.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.gradle.external.javadoc.StandardJavadocDocletOptions Maven / Gradle / Ivy

/*
 * Copyright 2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.external.javadoc;

import org.gradle.external.javadoc.internal.GroupsJavadocOptionFileOption;
import org.gradle.external.javadoc.internal.JavadocOptionFile;
import org.gradle.external.javadoc.internal.LinksOfflineJavadocOptionFileOption;

import java.io.File;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * Provides the options for the standard Javadoc doclet.
 */
public class StandardJavadocDocletOptions extends CoreJavadocOptions implements MinimalJavadocOptions {

    public StandardJavadocDocletOptions() {
        this(new JavadocOptionFile());
    }

    public StandardJavadocDocletOptions(JavadocOptionFile javadocOptionFile) {
        super(javadocOptionFile);

        destinationDirectory = addFileOption("d");
        use = addBooleanOption("use");
        version = addBooleanOption("version");
        author = addBooleanOption("author");
        splitIndex = addBooleanOption("splitindex");
        header = addStringOption("header");
        windowTitle = addStringOption("windowtitle");
        docTitle = addStringOption("doctitle");
        footer = addStringOption("footer");
        bottom = addStringOption("bottom");
        links = addMultilineStringsOption("link");
        linksOffline = addOption(new LinksOfflineJavadocOptionFileOption("linkoffline"));
        linkSource = addBooleanOption("linksource");
        groups = addOption(new GroupsJavadocOptionFileOption("group"));
        noDeprecated = addBooleanOption("nodeprecated");
        noDeprecatedList = addBooleanOption("nodeprecatedlist");
        noSince = addBooleanOption("nosince");
        noTree = addBooleanOption("notree");
        noIndex = addBooleanOption("noindex");
        noHelp = addBooleanOption("nohelp");
        noNavBar = addBooleanOption("nonavbar");
        helpFile = addFileOption("helpfile");
        stylesheetFile = addFileOption("stylesheetfile");
        serialWarn = addBooleanOption("serialwarn");
        charSet = addStringOption("charset");
        docEncoding = addStringOption("docencoding");
        keyWords = addBooleanOption("keywords");
        tags = addMultilineStringsOption("tag");
        taglets = addMultilineStringsOption("taglet");
        tagletPath = addPathOption("tagletpath");
        docFilesSubDirs = addBooleanOption("docfilessubdirs");
        excludeDocFilesSubDir = addStringsOption("excludedocfilessubdir", ":");
        noQualifiers = addStringsOption("noqualifier", ":");
        noTimestamp = addBooleanOption("notimestamp");
        noComment = addBooleanOption("nocomment");
    }

    /**
     * -d  directory
     * Specifies the destination directory where javadoc saves the generated HTML files. (The "d" means "destination.")
     * Omitting this option causes the files to be saved to the current directory.
     * The value directory can be absolute, or relative to the current working directory.
     * As of 1.4, the destination directory is automatically created when javadoc is run.
     * For example, the following generates the documentation for the package com.mypackage and
     * saves the results in the C:/user/doc/ directory:
     * 

     * C:> javadoc -d /user/doc com.mypackage
     */
    private final JavadocOptionFileOption destinationDirectory;

    @Override
    public File getDestinationDirectory() {
        return destinationDirectory.getValue();
    }

    @Override
    public void setDestinationDirectory(File directory) {
        this.destinationDirectory.setValue(directory);
    }

    @Override
    public StandardJavadocDocletOptions destinationDirectory(File destinationDirectory) {
        setDestinationDirectory(destinationDirectory);
        return this;
    }

    /**
     * -use
     * Includes one "Use" page for each documented class and package. The page describes what packages, classes, methods,
     * constructors and fields use any API of the given class or package. Given class C,
     * things that use class C would include subclasses of C, fields declared as C, methods that return C,
     * and methods and constructors with parameters of type C.
     * For example, let's look at what might appear on the "Use" page for String.
     * The getName() method in the java.awt.Font class returns type String. Therefore, getName() uses String,
     * and you will find that method on the "Use" page for String.
     * 

     * Note that this documents only uses of the API, not the implementation.
     * If a method uses String in its implementation but does not take a string as an argument or return a string,
     * that is not considered a "use" of String.
     * 

     * You can access the generated "Use" page by first going to the class or package,
     * then clicking on the "Use" link in the navigation bar.
     */
    private final JavadocOptionFileOption use;

    public boolean isUse() {
        return use.getValue();
    }

    public void setUse(boolean use) {
        this.use.setValue(use);
    }

    public StandardJavadocDocletOptions use(boolean use) {
        setUse(use);
        return this;
    }

    public StandardJavadocDocletOptions use() {
        return use(true);
    }

    /**
     * -version
     * Includes the @version text in the generated docs. This text is omitted by default.
     * To tell what version of the Javadoc tool you are using, use the -J-version option.
     */
    private final JavadocOptionFileOption version;

    public boolean isVersion() {
        return version.getValue();
    }

    public void setVersion(boolean version) {
        this.version.setValue(version);
    }

    public StandardJavadocDocletOptions version(boolean version) {
        setVersion(version);
        return this;
    }

    public StandardJavadocDocletOptions version() {
        return version(true);
    }

    /**
     * -author
     * Includes the @author text in the generated docs.
     */
    private final JavadocOptionFileOption author;

    public boolean isAuthor() {
        return author.getValue();
    }

    public void setAuthor(boolean author) {
        this.author.setValue(author);
    }

    public StandardJavadocDocletOptions author(boolean author) {
        setAuthor(author);
        return this;
    }

    public StandardJavadocDocletOptions author() {
        return author(true);
    }

    /**
     * -splitindex
     * Splits the index file into multiple files, alphabetically, one file per letter,
     * plus a file for any index entries that start with non-alphabetical characters.
     */
    private final JavadocOptionFileOption splitIndex;

    public boolean isSplitIndex() {
        return splitIndex.getValue();
    }

    public void setSplitIndex(boolean splitIndex) {
        this.splitIndex.setValue(splitIndex);
    }

    public StandardJavadocDocletOptions splitIndex(boolean splitIndex) {
        setSplitIndex(splitIndex);
        return this;
    }

    public StandardJavadocDocletOptions splitIndex() {
        return splitIndex(true);
    }

    /**
     * -windowtitle  title
     * Specifies the title to be placed in the HTML