langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/BaseConfiguration.java
author ksrini
Mon, 05 Jun 2017 13:45:34 -0700
changeset 45417 f7479ee8de69
parent 45157 langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/Configuration.java@f5f796453339
child 45420 036dbf8b3817
permissions -rw-r--r--
8177848: Rename Configuration(Impl) classes Reviewed-by: jjg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
/*
43872
b5ce3bc28931 8174839: javadoc crashes with a method which does not override a super.
ksrini
parents: 43261
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    23
 * questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    26
package jdk.javadoc.internal.doclets.toolkit;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
14258
8d2148961366 8000663: clean up langtools imports
jjg
parents: 14061
diff changeset
    28
import java.io.*;
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
    29
import java.lang.ref.*;
14258
8d2148961366 8000663: clean up langtools imports
jjg
parents: 14061
diff changeset
    30
import java.util.*;
35419
6adb831721fe 8148413: Memory leak in javadoc VisibleMemberMap
jjg
parents: 25874
diff changeset
    31
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    32
import javax.lang.model.element.Element;
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
    33
import javax.lang.model.element.ModuleElement;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    34
import javax.lang.model.element.PackageElement;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    35
import javax.lang.model.element.TypeElement;
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
    36
import javax.lang.model.util.SimpleElementVisitor9;
22153
f9f06fcca59d 8029800: Flags.java uses String.toLowerCase without specifying Locale
jlahoda
parents: 19937
diff changeset
    37
import javax.tools.JavaFileManager;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    38
import javax.tools.JavaFileObject;
14258
8d2148961366 8000663: clean up langtools imports
jjg
parents: 14061
diff changeset
    39
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    40
import com.sun.source.util.DocTreePath;
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
    41
import com.sun.tools.javac.util.DefinedBy;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
    42
import com.sun.tools.javac.util.DefinedBy.Api;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    43
import jdk.javadoc.doclet.Doclet;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    44
import jdk.javadoc.doclet.DocletEnvironment;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    45
import jdk.javadoc.doclet.Reporter;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    46
import jdk.javadoc.internal.doclets.toolkit.builders.BuilderFactory;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    47
import jdk.javadoc.internal.doclets.toolkit.taglets.TagletManager;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    48
import jdk.javadoc.internal.doclets.toolkit.util.DocFile;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    49
import jdk.javadoc.internal.doclets.toolkit.util.DocFileFactory;
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
    50
import jdk.javadoc.internal.doclets.toolkit.util.DocFileIOException;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    51
import jdk.javadoc.internal.doclets.toolkit.util.DocletConstants;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    52
import jdk.javadoc.internal.doclets.toolkit.util.Extern;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    53
import jdk.javadoc.internal.doclets.toolkit.util.Group;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    54
import jdk.javadoc.internal.doclets.toolkit.util.MetaKeywords;
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
    55
import jdk.javadoc.internal.doclets.toolkit.util.SimpleDocletException;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    56
import jdk.javadoc.internal.doclets.toolkit.util.TypeElementCatalog;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    57
import jdk.javadoc.internal.doclets.toolkit.util.Utils;
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
    58
import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    59
import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap.GetterSetter;
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
    60
import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap.Kind;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    61
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
    62
import static javax.tools.Diagnostic.Kind.*;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    63
06bc494ca11e Initial load
duke
parents:
diff changeset
    64
/**
06bc494ca11e Initial load
duke
parents:
diff changeset
    65
 * Configure the output based on the options. Doclets should sub-class
45417
f7479ee8de69 8177848: Rename Configuration(Impl) classes
ksrini
parents: 45157
diff changeset
    66
 * BaseConfiguration, to configure and add their own options. This class contains
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    67
 * all user options which are supported by the 1.1 doclet and the standard
06bc494ca11e Initial load
duke
parents:
diff changeset
    68
 * doclet.
06bc494ca11e Initial load
duke
parents:
diff changeset
    69
 *
14260
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14258
diff changeset
    70
 *  <p><b>This is NOT part of any supported API.
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14258
diff changeset
    71
 *  If you write code that depends on this, you do so at your own risk.
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14258
diff changeset
    72
 *  This code and its internal interfaces are subject to change or
727a84636f12 8000665: fix "internal API" comments on javadoc files
jjg
parents: 14258
diff changeset
    73
 *  deletion without notice.</b>
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    74
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    75
 * @author Robert Field.
06bc494ca11e Initial load
duke
parents:
diff changeset
    76
 * @author Atul Dambalkar.
06bc494ca11e Initial load
duke
parents:
diff changeset
    77
 * @author Jamie Ho
06bc494ca11e Initial load
duke
parents:
diff changeset
    78
 */
45417
f7479ee8de69 8177848: Rename Configuration(Impl) classes
ksrini
parents: 45157
diff changeset
    79
public abstract class BaseConfiguration {
44388
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
    80
    /**
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
    81
     * The doclet that created this configuration.
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
    82
     */
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
    83
    public final Doclet doclet;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    86
     * The factory for builders.
06bc494ca11e Initial load
duke
parents:
diff changeset
    87
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    88
    protected BuilderFactory builderFactory;
06bc494ca11e Initial load
duke
parents:
diff changeset
    89
06bc494ca11e Initial load
duke
parents:
diff changeset
    90
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    91
     * The taglet manager.
06bc494ca11e Initial load
duke
parents:
diff changeset
    92
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    93
    public TagletManager tagletManager;
06bc494ca11e Initial load
duke
parents:
diff changeset
    94
06bc494ca11e Initial load
duke
parents:
diff changeset
    95
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    96
     * The path to the builder XML input file.
06bc494ca11e Initial load
duke
parents:
diff changeset
    97
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
    public String builderXMLPath;
06bc494ca11e Initial load
duke
parents:
diff changeset
    99
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
     * The default path to the builder XML.
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
     */
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   103
    public static final String DEFAULT_BUILDER_XML = "resources/doclet.xml";
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   104
06bc494ca11e Initial load
duke
parents:
diff changeset
   105
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
     * The path to Taglets
06bc494ca11e Initial load
duke
parents:
diff changeset
   107
     */
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   108
    public String tagletpath = null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   109
06bc494ca11e Initial load
duke
parents:
diff changeset
   110
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   111
     * This is true if option "-serialwarn" is used. Defualt value is false to
14545
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   112
     * suppress excessive warnings about serial tag.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   113
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   114
    public boolean serialwarn = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   115
06bc494ca11e Initial load
duke
parents:
diff changeset
   116
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   117
     * The specified amount of space between tab stops.
06bc494ca11e Initial load
duke
parents:
diff changeset
   118
     */
14542
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   119
    public int sourcetab;
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   120
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   121
    public String tabSpaces;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   122
06bc494ca11e Initial load
duke
parents:
diff changeset
   123
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   124
     * True if we should generate browsable sources.
06bc494ca11e Initial load
duke
parents:
diff changeset
   125
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   126
    public boolean linksource = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   127
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   129
     * True if command line option "-nosince" is used. Default value is
06bc494ca11e Initial load
duke
parents:
diff changeset
   130
     * false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   131
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
    public boolean nosince = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
     * True if we should recursively copy the doc-file subdirectories
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
    public boolean copydocfilesubdirs = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
    /**
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   140
     * Maintain backward compatibility with previous javadoc version
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   141
     */
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   142
    public boolean backwardCompatibility = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   143
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   144
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
     * The META charset tag used for cross-platform viewing.
06bc494ca11e Initial load
duke
parents:
diff changeset
   146
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   147
    public String charset = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
06bc494ca11e Initial load
duke
parents:
diff changeset
   149
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
     * True if user wants to add member names as meta keywords.
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
     * Set to false because meta keywords are ignored in general
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
     * by most Internet search engines.
06bc494ca11e Initial load
duke
parents:
diff changeset
   153
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   154
    public boolean keywords = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   155
06bc494ca11e Initial load
duke
parents:
diff changeset
   156
    /**
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   157
     * The meta tag keywords instance.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
     */
25454
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   159
    public final MetaKeywords metakeywords;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
    /**
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   162
     * The set of doc-file subdirectories to exclude
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
     */
868
d0f233085cbb 6657907: javadoc has unchecked warnings
jjg
parents: 10
diff changeset
   164
    protected Set<String> excludedDocFileDirs;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
    /**
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   167
     * The set of qualifiers to exclude
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
     */
868
d0f233085cbb 6657907: javadoc has unchecked warnings
jjg
parents: 10
diff changeset
   169
    protected Set<String> excludedQualifiers;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   170
06bc494ca11e Initial load
duke
parents:
diff changeset
   171
    /**
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   172
     * The doclet environment.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
     */
39364
bd6d4a7936b4 8160301: javadoc RootDoclmpl and DocEnv needs to be renamed
ksrini
parents: 39181
diff changeset
   174
    public DocletEnvironment docEnv;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
    /**
25454
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   177
     * An utility class for commonly used helpers
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   178
     */
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   179
    public Utils utils;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   180
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   181
    /**
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   182
     * All the temporary accessors to javac internals.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   183
     */
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   184
    public WorkArounds workArounds;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   185
25454
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   186
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   187
     * Destination directory name, in which doclet will generate the entire
06bc494ca11e Initial load
duke
parents:
diff changeset
   188
     * documentation. Default is current directory.
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
    public String destDirName = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
     * Destination directory name, in which doclet will copy the doc-files to.
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   195
    public String docFileDestDirName = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
06bc494ca11e Initial load
duke
parents:
diff changeset
   197
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
     * Encoding for this document. Default is default encoding for this
06bc494ca11e Initial load
duke
parents:
diff changeset
   199
     * platform.
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
    public String docencoding = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
     * True if user wants to suppress descriptions and tags.
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
    public boolean nocomment = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
06bc494ca11e Initial load
duke
parents:
diff changeset
   208
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
     * Encoding for this document. Default is default encoding for this
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
     * platform.
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
    public String encoding = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   213
06bc494ca11e Initial load
duke
parents:
diff changeset
   214
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   215
     * Generate author specific information for all the classes if @author
06bc494ca11e Initial load
duke
parents:
diff changeset
   216
     * tag is used in the doc comment and if -author option is used.
06bc494ca11e Initial load
duke
parents:
diff changeset
   217
     * <code>showauthor</code> is set to true if -author option is used.
06bc494ca11e Initial load
duke
parents:
diff changeset
   218
     * Default is don't show author information.
06bc494ca11e Initial load
duke
parents:
diff changeset
   219
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
    public boolean showauthor = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   221
06bc494ca11e Initial load
duke
parents:
diff changeset
   222
    /**
16319
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   223
     * Generate documentation for JavaFX getters and setters automatically
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   224
     * by copying it from the appropriate property definition.
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   225
     */
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   226
    public boolean javafx = false;
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   227
e586bfeb39c5 7112427: The doclet needs to be able to generate JavaFX documentation.
jjg
parents: 15725
diff changeset
   228
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   229
     * Generate version specific information for the all the classes
06bc494ca11e Initial load
duke
parents:
diff changeset
   230
     * if @version tag is used in the doc comment and if -version option is
06bc494ca11e Initial load
duke
parents:
diff changeset
   231
     * used. <code>showversion</code> is set to true if -version option is
06bc494ca11e Initial load
duke
parents:
diff changeset
   232
     * used.Default is don't show version information.
06bc494ca11e Initial load
duke
parents:
diff changeset
   233
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   234
    public boolean showversion = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   235
06bc494ca11e Initial load
duke
parents:
diff changeset
   236
    /**
43261
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   237
     * Allow JavaScript in doc comments.
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   238
     */
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   239
    private boolean allowScriptInComments = false;
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   240
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   241
    /**
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   242
     * Sourcepath from where to read the source files. Default is classpath.
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   243
     *
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   244
     */
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   245
    public String sourcepath = "";
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   246
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   247
    /**
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   248
     * Generate modules documentation if more than one module is present.
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   249
     */
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   250
    public boolean showModules = false;
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   251
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   252
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   253
     * Don't generate deprecated API information at all, if -nodeprecated
06bc494ca11e Initial load
duke
parents:
diff changeset
   254
     * option is used. <code>nodepracted</code> is set to true if
06bc494ca11e Initial load
duke
parents:
diff changeset
   255
     * -nodeprecated option is used. Default is generate deprected API
06bc494ca11e Initial load
duke
parents:
diff changeset
   256
     * information.
06bc494ca11e Initial load
duke
parents:
diff changeset
   257
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   258
    public boolean nodeprecated = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   259
06bc494ca11e Initial load
duke
parents:
diff changeset
   260
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   261
     * The catalog of classes specified on the command-line
06bc494ca11e Initial load
duke
parents:
diff changeset
   262
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   263
    public TypeElementCatalog typeElementCatalog;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   264
06bc494ca11e Initial load
duke
parents:
diff changeset
   265
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   266
     * True if user wants to suppress time stamp in output.
06bc494ca11e Initial load
duke
parents:
diff changeset
   267
     * Default is false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   268
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   269
    public boolean notimestamp= false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
06bc494ca11e Initial load
duke
parents:
diff changeset
   271
    /**
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   272
     * The package grouping instance.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   273
     */
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   274
    public final Group group = new Group(this);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   275
06bc494ca11e Initial load
duke
parents:
diff changeset
   276
    /**
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   277
     * The tracker of external package links.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   279
    public final Extern extern = new Extern(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   281
    public  Reporter reporter;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   282
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   283
    public Locale locale;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   284
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   285
    /**
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   286
     * Suppress all messages
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   287
     */
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   288
    public boolean quiet = false;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   289
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   290
    private String urlForLink;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   291
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   292
    private String pkglistUrlForLink;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   293
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   294
    private String urlForLinkOffline;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   295
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   296
    private String pkglistUrlForLinkOffline;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   297
41451
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   298
    public boolean dumpOnError = false;
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   299
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   300
    private List<GroupContainer> groups;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   301
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
   302
    private final Map<TypeElement, EnumMap<Kind, Reference<VisibleMemberMap>>> typeElementMemberCache;
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
   303
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   304
    public abstract Messages getMessages();
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   305
    public abstract Resources getResources();
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   306
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   307
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   308
     * Return the build date for the doclet.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   309
     *
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   310
     * @return the build date
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   311
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   312
    public abstract String getDocletSpecificBuildDate();
06bc494ca11e Initial load
duke
parents:
diff changeset
   313
06bc494ca11e Initial load
duke
parents:
diff changeset
   314
    /**
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   315
     * This method should be defined in all those doclets (configurations),
45417
f7479ee8de69 8177848: Rename Configuration(Impl) classes
ksrini
parents: 45157
diff changeset
   316
     * which want to derive themselves from this BaseConfiguration. This method
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   317
     * can be used to finish up the options setup.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   318
     *
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   319
     * @return true if successful and false otherwise
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   321
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   322
    public abstract boolean finishOptionSettings();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   323
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   324
    public CommentUtils cmtUtils;
15723
58a73dac9ee4 8006124: javadoc/doclet should be updated to support profiles
bpatel
parents: 14545
diff changeset
   325
58a73dac9ee4 8006124: javadoc/doclet should be updated to support profiles
bpatel
parents: 14545
diff changeset
   326
    /**
41633
eec0f5b0465f 8167383: Javadoc does not handle packages correctly when used with module option.
ksrini
parents: 41451
diff changeset
   327
     * A sorted set of included packages.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   328
     */
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   329
    public SortedSet<PackageElement> packages = null;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   330
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   331
    public OverviewElement overviewElement;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
35419
6adb831721fe 8148413: Memory leak in javadoc VisibleMemberMap
jjg
parents: 25874
diff changeset
   333
    // The following three fields provide caches for use by all instances of VisibleMemberMap.
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   334
    public final Map<TypeElement, List<Element>> propertiesCache = new HashMap<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   335
    public final Map<Element, Element> classPropertiesMap = new HashMap<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   336
    public final Map<Element, GetterSetter> getterSetterMap = new HashMap<>();
35419
6adb831721fe 8148413: Memory leak in javadoc VisibleMemberMap
jjg
parents: 25874
diff changeset
   337
35420
9303ae941f69 8148417: Memory leak in javadoc DocFileFactory
jjg
parents: 35419
diff changeset
   338
    public DocFileFactory docFileFactory;
9303ae941f69 8148417: Memory leak in javadoc DocFileFactory
jjg
parents: 35419
diff changeset
   339
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
    /**
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   341
     * A sorted map, giving the (specified|included|other) packages for each module.
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   342
     */
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   343
    public SortedMap<ModuleElement, Set<PackageElement>> modulePackages;
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   344
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   345
   /**
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   346
    * The list of known modules, that should be documented.
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   347
    */
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   348
    public SortedSet<ModuleElement> modules;
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   349
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   350
    protected static final String sharedResourceBundleName =
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   351
            "jdk.javadoc.internal.doclets.toolkit.resources.doclets";
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   352
    /**
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   353
     * Constructs the configurations needed by the doclet.
44388
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
   354
     * @param doclet the doclet that created this configuration
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   355
     */
45417
f7479ee8de69 8177848: Rename Configuration(Impl) classes
ksrini
parents: 45157
diff changeset
   356
    public BaseConfiguration(Doclet doclet) {
44388
4d0903f1f311 8176836: Provide Taglet with context
jjg
parents: 44293
diff changeset
   357
        this.doclet = doclet;
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   358
        excludedDocFileDirs = new HashSet<>();
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   359
        excludedQualifiers = new HashSet<>();
14542
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   360
        setTabWidth(DocletConstants.DEFAULT_TAB_STOP_LENGTH);
25454
376a52c9540c 8039028: [javadoc] refactor the usage of Util.java
ksrini
parents: 24221
diff changeset
   361
        metakeywords = new MetaKeywords(this);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   362
        groups = new ArrayList<>(0);
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
   363
        typeElementMemberCache = new HashMap<>();
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   364
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   365
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   366
    private boolean initialized = false;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   367
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   368
    protected void initConfiguration(DocletEnvironment docEnv) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   369
        if (initialized) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   370
            throw new IllegalStateException("configuration previously initialized");
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   371
        }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   372
        initialized = true;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   373
        this.docEnv = docEnv;
39364
bd6d4a7936b4 8160301: javadoc RootDoclmpl and DocEnv needs to be renamed
ksrini
parents: 39181
diff changeset
   374
        overviewElement = new OverviewElement(docEnv);
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   375
        Splitter specifiedSplitter = new Splitter(docEnv, false);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   376
        specifiedModuleElements = Collections.unmodifiableSet(specifiedSplitter.mset);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   377
        specifiedPackageElements = Collections.unmodifiableSet(specifiedSplitter.pset);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   378
        specifiedTypeElements = Collections.unmodifiableSet(specifiedSplitter.tset);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   379
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   380
        Splitter includedSplitter = new Splitter(docEnv, true);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   381
        includedModuleElements = Collections.unmodifiableSet(includedSplitter.mset);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   382
        includedPackageElements = Collections.unmodifiableSet(includedSplitter.pset);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   383
        includedTypeElements = Collections.unmodifiableSet(includedSplitter.tset);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
     * Return the builder factory for this doclet.
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
     * @return the builder factory for this doclet.
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   391
    public BuilderFactory getBuilderFactory() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
        if (builderFactory == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
            builderFactory = new BuilderFactory(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   394
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   395
        return builderFactory;
06bc494ca11e Initial load
duke
parents:
diff changeset
   396
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   397
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   398
    public Reporter getReporter() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   399
        return this.reporter;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   400
    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   401
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   402
    private Set<ModuleElement> specifiedModuleElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   403
    public Set<ModuleElement> getSpecifiedModuleElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   404
        return specifiedModuleElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   405
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   406
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   407
    private Set<PackageElement> specifiedPackageElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   408
    public Set<PackageElement> getSpecifiedPackageElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   409
        return specifiedPackageElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   410
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   411
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   412
    private Set<TypeElement> specifiedTypeElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   413
    public Set<TypeElement> getSpecifiedTypeElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   414
        return specifiedTypeElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   415
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   416
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   417
    private Set<ModuleElement> includedModuleElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   418
    public Set<ModuleElement> getIncludedModuleElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   419
        return includedModuleElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   420
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   421
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   422
    private Set<PackageElement> includedPackageElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   423
    public Set<PackageElement> getIncludedPackageElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   424
        return includedPackageElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   425
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   426
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   427
    private Set<TypeElement> includedTypeElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   428
    public Set<TypeElement> getIncludedTypeElements() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   429
        return includedTypeElements;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   430
    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   431
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   432
    private void initModules() {
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   433
        // Build the modules structure used by the doclet
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   434
        modules = new TreeSet<>(utils.makeModuleComparator());
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   435
        modules.addAll(getSpecifiedModuleElements());
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   436
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   437
        modulePackages = new TreeMap<>(utils.makeModuleComparator());
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   438
        for (PackageElement p: packages) {
39364
bd6d4a7936b4 8160301: javadoc RootDoclmpl and DocEnv needs to be renamed
ksrini
parents: 39181
diff changeset
   439
            ModuleElement mdle = docEnv.getElementUtils().getModuleOf(p);
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   440
            if (mdle != null && !mdle.isUnnamed()) {
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   441
                Set<PackageElement> s = modulePackages
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   442
                        .computeIfAbsent(mdle, m -> new TreeSet<>(utils.makePackageComparator()));
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   443
                s.add(p);
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   444
            }
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   445
        }
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   446
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   447
        for (PackageElement p: getIncludedPackageElements()) {
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   448
            ModuleElement mdle = docEnv.getElementUtils().getModuleOf(p);
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   449
            if (mdle != null && !mdle.isUnnamed()) {
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   450
                Set<PackageElement> s = modulePackages
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   451
                        .computeIfAbsent(mdle, m -> new TreeSet<>(utils.makePackageComparator()));
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   452
                s.add(p);
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   453
            }
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   454
        }
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   455
44293
2f47b2c16612 8176778: javadoc does not produce summary pages for aggregated modules
ksrini
parents: 43872
diff changeset
   456
        // add entries for modules which may not have exported packages
2f47b2c16612 8176778: javadoc does not produce summary pages for aggregated modules
ksrini
parents: 43872
diff changeset
   457
        modules.forEach((ModuleElement mdle) -> {
2f47b2c16612 8176778: javadoc does not produce summary pages for aggregated modules
ksrini
parents: 43872
diff changeset
   458
            modulePackages.computeIfAbsent(mdle, m -> Collections.emptySet());
2f47b2c16612 8176778: javadoc does not produce summary pages for aggregated modules
ksrini
parents: 43872
diff changeset
   459
        });
2f47b2c16612 8176778: javadoc does not produce summary pages for aggregated modules
ksrini
parents: 43872
diff changeset
   460
37943
2efb75c09230 8154262: Navigation bar in javadoc generated pages needs to be updated to display module information
bpatel
parents: 37848
diff changeset
   461
        modules.addAll(modulePackages.keySet());
40508
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   462
        showModules = !modules.isEmpty();
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   463
        for (Set<PackageElement> pkgs : modulePackages.values()) {
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   464
            packages.addAll(pkgs);
74ef30d16fb9 8159305: Enhance the javadoc tool to support module related options
ksrini
parents: 40314
diff changeset
   465
        }
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   466
    }
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   467
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   468
    private void initPackages() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   469
        packages = new TreeSet<>(utils.makePackageComparator());
41633
eec0f5b0465f 8167383: Javadoc does not handle packages correctly when used with module option.
ksrini
parents: 41451
diff changeset
   470
        // add all the included packages
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   471
        packages.addAll(includedPackageElements);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   472
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   473
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   474
    public Set<Doclet.Option> getSupportedOptions() {
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   475
        Resources resources = getResources();
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   476
        Doclet.Option[] options = {
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   477
            new Option(resources, "-author") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   478
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   479
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   480
                    showauthor = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   481
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   482
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   483
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   484
            new Option(resources, "-d", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   485
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   486
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   487
                    destDirName = addTrailingFileSep(args.get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   488
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   489
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   490
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   491
            new Option(resources, "-docencoding", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   492
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   493
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   494
                    docencoding = args.get(0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   495
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   496
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   497
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   498
            new Option(resources, "-docfilessubdirs") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   499
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   500
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   501
                    copydocfilesubdirs = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   502
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   503
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   504
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   505
            new Hidden(resources, "-encoding", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   506
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   507
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   508
                    encoding = args.get(0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   509
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   510
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   511
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   512
            new Option(resources, "-excludedocfilessubdir", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   513
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   514
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   515
                    addToSet(excludedDocFileDirs, args.get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   516
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   517
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   518
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   519
            new Option(resources, "-group", 2) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   520
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   521
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   522
                    groups.add(new GroupContainer(args.get(0), args.get(1)));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   523
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   524
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   525
            },
44815
2a0f6c7033bd 8178830: standard doclet: -javafx option should be unhidden
ksrini
parents: 44460
diff changeset
   526
            new Option(resources, "--javafx -javafx") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   527
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   528
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   529
                    javafx = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   530
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   531
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   532
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   533
            new Option(resources, "-keywords") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   534
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   535
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   536
                    keywords = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   537
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   538
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   539
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   540
            new Option(resources, "-link", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   541
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   542
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   543
                    urlForLink = args.get(0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   544
                    pkglistUrlForLink = urlForLink;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   545
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   546
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   547
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   548
            new Option(resources, "-linksource") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   549
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   550
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   551
                    linksource = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   552
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   553
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   554
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   555
            new Option(resources, "-linkoffline", 2) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   556
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   557
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   558
                    urlForLinkOffline = args.get(0);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   559
                    pkglistUrlForLinkOffline = args.get(1);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   560
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   561
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   562
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   563
            new Option(resources, "-nocomment") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   564
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   565
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   566
                    nocomment = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   567
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   568
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   569
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   570
            new Option(resources, "-nodeprecated") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   571
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   572
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   573
                    nodeprecated = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   574
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   575
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   576
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   577
            new Option(resources, "-nosince") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   578
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   579
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   580
                    nosince = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   581
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   582
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   583
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   584
            new Option(resources, "-notimestamp") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   585
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   586
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   587
                    notimestamp = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   588
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   589
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   590
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   591
            new Option(resources, "-noqualifier", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   592
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   593
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   594
                    addToSet(excludedQualifiers, args.get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   595
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   596
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   597
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   598
            new Hidden(resources, "-quiet") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   599
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   600
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   601
                    quiet = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   602
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   603
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   604
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   605
            new Option(resources, "-serialwarn") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   606
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   607
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   608
                    serialwarn = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   609
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   610
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   611
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   612
            new Option(resources, "-sourcetab", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   613
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   614
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   615
                    linksource = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   616
                    try {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   617
                        setTabWidth(Integer.parseInt(args.get(0)));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   618
                    } catch (NumberFormatException e) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   619
                             //Set to -1 so that warning will be printed
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   620
                        //to indicate what is valid argument.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   621
                        sourcetab = -1;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   622
                    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   623
                    if (sourcetab <= 0) {
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   624
                        getMessages().warning("doclet.sourcetab_warning");
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   625
                        setTabWidth(DocletConstants.DEFAULT_TAB_STOP_LENGTH);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   626
                    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   627
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   628
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   629
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   630
            new Option(resources, "-tag", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   631
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   632
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   633
                    ArrayList<String> list = new ArrayList<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   634
                    list.add(opt);
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   635
                    list.add(args.get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   636
                    customTagStrs.add(list);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   637
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   638
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   639
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   640
             new Option(resources, "-taglet", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   641
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   642
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   643
                    ArrayList<String> list = new ArrayList<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   644
                    list.add(opt);
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   645
                    list.add(args.get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   646
                    customTagStrs.add(list);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   647
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   648
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   649
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   650
            new Option(resources, "-tagletpath", 1) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   651
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   652
                public boolean process(String opt, List<String> args) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   653
                    tagletpath = args.get(0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   654
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   655
                }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   656
            },
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
   657
            new Option(resources, "-version") {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   658
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   659
                public boolean process(String opt, List<String> args) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   660
                    showversion = true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   661
                    return true;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   662
                }
41451
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   663
            },
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   664
            new Hidden(resources, "--dump-on-error") {
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   665
                @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   666
                public boolean process(String opt, List<String> args) {
41451
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   667
                    dumpOnError = true;
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   668
                    return true;
a847c7aa25a7 8151102: Cleanup javadoc exception handling
ksrini
parents: 41252
diff changeset
   669
                }
43261
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   670
            },
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   671
            new Option(resources, "--allow-script-in-comments") {
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   672
                @Override
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   673
                public boolean process(String opt, List<String> args) {
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   674
                    allowScriptInComments = true;
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   675
                    return true;
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
   676
                }
19937
7dacecdfbad4 8015496: Information that package is deprecated is missing in profiles view
bpatel
parents: 19911
diff changeset
   677
            }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   678
        };
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   679
        Set<Doclet.Option> set = new TreeSet<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   680
        set.addAll(Arrays.asList(options));
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   681
        return set;
15723
58a73dac9ee4 8006124: javadoc/doclet should be updated to support profiles
bpatel
parents: 14545
diff changeset
   682
    }
58a73dac9ee4 8006124: javadoc/doclet should be updated to support profiles
bpatel
parents: 14545
diff changeset
   683
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   684
    final LinkedHashSet<List<String>> customTagStrs = new LinkedHashSet<>();
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   685
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   686
    /*
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   687
     * when this is called all the option have been set, this method,
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   688
     * initializes certain components before anything else is started.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   689
     */
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   690
    private void finishOptionSettings0() throws DocletException {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   691
        initDestDirectory();
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   692
        if (urlForLink != null && pkglistUrlForLink != null)
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   693
            extern.link(urlForLink, pkglistUrlForLink, reporter, false);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   694
        if (urlForLinkOffline != null && pkglistUrlForLinkOffline != null)
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   695
            extern.link(urlForLinkOffline, pkglistUrlForLinkOffline, reporter, true);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   696
        if (docencoding == null) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   697
            docencoding = encoding;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   698
        }
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   699
        typeElementCatalog = new TypeElementCatalog(includedTypeElements, this);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   700
        initTagletManager(customTagStrs);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   701
        groups.stream().forEach((grp) -> {
45157
f5f796453339 8178043: Support grouping modules in unified javadoc
bpatel
parents: 44815
diff changeset
   702
            if (showModules) {
f5f796453339 8178043: Support grouping modules in unified javadoc
bpatel
parents: 44815
diff changeset
   703
                group.checkModuleGroups(grp.value1, grp.value2);
f5f796453339 8178043: Support grouping modules in unified javadoc
bpatel
parents: 44815
diff changeset
   704
            } else {
f5f796453339 8178043: Support grouping modules in unified javadoc
bpatel
parents: 44815
diff changeset
   705
                group.checkPackageGroups(grp.value1, grp.value2);
f5f796453339 8178043: Support grouping modules in unified javadoc
bpatel
parents: 44815
diff changeset
   706
            }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   707
        });
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   708
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   709
06bc494ca11e Initial load
duke
parents:
diff changeset
   710
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   711
     * Set the command line options supported by this configuration.
06bc494ca11e Initial load
duke
parents:
diff changeset
   712
     *
36526
3b41f1c69604 8142968: Module System implementation
alanb
parents: 36037
diff changeset
   713
     * @return true if the options are set successfully
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   714
     * @throws DocletException if there is a problem while setting the options
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   715
     */
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   716
    public boolean setOptions() throws DocletException {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   717
        initPackages();
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   718
        initModules();
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   719
        finishOptionSettings0();
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   720
        if (!finishOptionSettings())
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   721
            return false;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   722
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   723
        return true;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   724
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   725
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   726
    private void initDestDirectory() throws DocletException {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   727
        if (!destDirName.isEmpty()) {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   728
            DocFile destDir = DocFile.createFileForDirectory(this, destDirName);
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   729
            if (!destDir.exists()) {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   730
                //Create the output directory (in case it doesn't exist yet)
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   731
                reporter.print(NOTE, getText("doclet.dest_dir_create", destDirName));
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   732
                destDir.mkdirs();
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   733
            } else if (!destDir.isDirectory()) {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   734
                throw new SimpleDocletException(getText(
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   735
                        "doclet.destination_directory_not_directory_0",
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   736
                        destDir.getPath()));
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   737
            } else if (!destDir.canWrite()) {
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   738
                throw new SimpleDocletException(getText(
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   739
                        "doclet.destination_directory_not_writable_0",
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   740
                        destDir.getPath()));
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   741
            }
16324
332d7f5fdf62 8008949: javadoc stopped copying doc-files
jjg
parents: 16319
diff changeset
   742
        }
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   743
        DocFileFactory.getFactory(this).setDestDir(destDirName);
16324
332d7f5fdf62 8008949: javadoc stopped copying doc-files
jjg
parents: 16319
diff changeset
   744
    }
332d7f5fdf62 8008949: javadoc stopped copying doc-files
jjg
parents: 16319
diff changeset
   745
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   746
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   747
     * Initialize the taglet manager.  The strings to initialize the simple custom tags should
06bc494ca11e Initial load
duke
parents:
diff changeset
   748
     * be in the following format:  "[tag name]:[location str]:[heading]".
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   749
     *
14545
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   750
     * @param customTagStrs the set two dimensional arrays of strings.  These arrays contain
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   751
     * either -tag or -taglet arguments.
06bc494ca11e Initial load
duke
parents:
diff changeset
   752
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   753
    private void initTagletManager(Set<List<String>> customTagStrs) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   754
        tagletManager = tagletManager == null ?
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   755
            new TagletManager(nosince, showversion, showauthor, javafx, this) :
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   756
            tagletManager;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   757
        for (List<String> args : customTagStrs) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   758
            if (args.get(0).equals("-taglet")) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   759
                tagletManager.addCustomTag(args.get(1), getFileManager(), tagletpath);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   760
                continue;
06bc494ca11e Initial load
duke
parents:
diff changeset
   761
            }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   762
            List<String> tokens = tokenize(args.get(1), TagletManager.SIMPLE_TAGLET_OPT_SEPARATOR, 3);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   763
            if (tokens.size() == 1) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   764
                String tagName = args.get(1);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   765
                if (tagletManager.isKnownCustomTag(tagName)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   766
                    //reorder a standard tag
06bc494ca11e Initial load
duke
parents:
diff changeset
   767
                    tagletManager.addNewSimpleCustomTag(tagName, null, "");
06bc494ca11e Initial load
duke
parents:
diff changeset
   768
                } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   769
                    //Create a simple tag with the heading that has the same name as the tag.
14263
473b1eaede64 8000310: Clean up use of StringBuffer in langtools
jjg
parents: 14260
diff changeset
   770
                    StringBuilder heading = new StringBuilder(tagName + ":");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   771
                    heading.setCharAt(0, Character.toUpperCase(tagName.charAt(0)));
06bc494ca11e Initial load
duke
parents:
diff changeset
   772
                    tagletManager.addNewSimpleCustomTag(tagName, heading.toString(), "a");
06bc494ca11e Initial load
duke
parents:
diff changeset
   773
                }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   774
            } else if (tokens.size() == 2) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   775
                //Add simple taglet without heading, probably to excluding it in the output.
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   776
                tagletManager.addNewSimpleCustomTag(tokens.get(0), tokens.get(1), "");
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   777
            } else if (tokens.size() >= 3) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   778
                tagletManager.addNewSimpleCustomTag(tokens.get(0), tokens.get(2), tokens.get(1));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   779
            } else {
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   780
                Messages messages = getMessages();
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   781
                messages.error("doclet.Error_invalid_custom_tag_argument", args.get(1));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   782
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   783
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   784
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   785
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   786
    /**
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   787
     * Given a string, return an array of tokens.  The separator can be escaped
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   788
     * with the '\' character.  The '\' character may also be escaped by the
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   789
     * '\' character.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   790
     *
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   791
     * @param s         the string to tokenize.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   792
     * @param separator the separator char.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   793
     * @param maxTokens the maximum number of tokens returned.  If the
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   794
     *                  max is reached, the remaining part of s is appended
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   795
     *                  to the end of the last token.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   796
     *
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   797
     * @return an array of tokens.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   798
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   799
    private List<String> tokenize(String s, char separator, int maxTokens) {
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   800
        List<String> tokens = new ArrayList<>();
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   801
        StringBuilder  token = new StringBuilder ();
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   802
        boolean prevIsEscapeChar = false;
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   803
        for (int i = 0; i < s.length(); i += Character.charCount(i)) {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   804
            int currentChar = s.codePointAt(i);
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   805
            if (prevIsEscapeChar) {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   806
                // Case 1:  escaped character
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   807
                token.appendCodePoint(currentChar);
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   808
                prevIsEscapeChar = false;
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   809
            } else if (currentChar == separator && tokens.size() < maxTokens-1) {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   810
                // Case 2:  separator
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   811
                tokens.add(token.toString());
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   812
                token = new StringBuilder();
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   813
            } else if (currentChar == '\\') {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   814
                // Case 3:  escape character
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   815
                prevIsEscapeChar = true;
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   816
            } else {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   817
                // Case 4:  regular character
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   818
                token.appendCodePoint(currentChar);
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   819
            }
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   820
        }
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   821
        if (token.length() > 0) {
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   822
            tokens.add(token.toString());
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   823
        }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   824
        return tokens;
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   825
    }
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
   826
868
d0f233085cbb 6657907: javadoc has unchecked warnings
jjg
parents: 10
diff changeset
   827
    private void addToSet(Set<String> s, String str){
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   828
        StringTokenizer st = new StringTokenizer(str, ":");
06bc494ca11e Initial load
duke
parents:
diff changeset
   829
        String current;
06bc494ca11e Initial load
duke
parents:
diff changeset
   830
        while(st.hasMoreTokens()){
06bc494ca11e Initial load
duke
parents:
diff changeset
   831
            current = st.nextToken();
06bc494ca11e Initial load
duke
parents:
diff changeset
   832
            s.add(current);
06bc494ca11e Initial load
duke
parents:
diff changeset
   833
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   834
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   835
06bc494ca11e Initial load
duke
parents:
diff changeset
   836
    /**
14061
9ac68cf0048b 4696488: javadoc doesn't handle UNC paths for destination directory
bpatel
parents: 13842
diff changeset
   837
     * Add a trailing file separator, if not found. Remove superfluous
9ac68cf0048b 4696488: javadoc doesn't handle UNC paths for destination directory
bpatel
parents: 13842
diff changeset
   838
     * file separators if any. Preserve the front double file separator for
9ac68cf0048b 4696488: javadoc doesn't handle UNC paths for destination directory
bpatel
parents: 13842
diff changeset
   839
     * UNC paths.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   840
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   841
     * @param path Path under consideration.
06bc494ca11e Initial load
duke
parents:
diff changeset
   842
     * @return String Properly constructed path string.
06bc494ca11e Initial load
duke
parents:
diff changeset
   843
     */
14061
9ac68cf0048b 4696488: javadoc doesn't handle UNC paths for destination directory
bpatel
parents: 13842
diff changeset
   844
    public static String addTrailingFileSep(String path) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   845
        String fs = System.getProperty("file.separator");
06bc494ca11e Initial load
duke
parents:
diff changeset
   846
        String dblfs = fs + fs;
06bc494ca11e Initial load
duke
parents:
diff changeset
   847
        int indexDblfs;
14061
9ac68cf0048b 4696488: javadoc doesn't handle UNC paths for destination directory
bpatel
parents: 13842
diff changeset
   848
        while ((indexDblfs = path.indexOf(dblfs, 1)) >= 0) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   849
            path = path.substring(0, indexDblfs) +
06bc494ca11e Initial load
duke
parents:
diff changeset
   850
                path.substring(indexDblfs + fs.length());
06bc494ca11e Initial load
duke
parents:
diff changeset
   851
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   852
        if (!path.endsWith(fs))
06bc494ca11e Initial load
duke
parents:
diff changeset
   853
            path += fs;
06bc494ca11e Initial load
duke
parents:
diff changeset
   854
        return path;
06bc494ca11e Initial load
duke
parents:
diff changeset
   855
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   856
06bc494ca11e Initial load
duke
parents:
diff changeset
   857
    /**
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   858
     *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   859
     * This checks for the validity of the options used by the user.
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   860
     * As of this writing, this checks only docencoding.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   861
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   862
     * @return true if all the options are valid.
06bc494ca11e Initial load
duke
parents:
diff changeset
   863
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   864
    public boolean generalValidOptions() {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   865
        if (docencoding != null) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   866
            if (!checkOutputFileEncoding(docencoding)) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   867
                return false;
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   868
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   869
        }
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
   870
        if (docencoding == null && (encoding != null && !encoding.isEmpty())) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   871
            if (!checkOutputFileEncoding(encoding)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   872
                return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   873
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   874
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   875
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   876
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   877
06bc494ca11e Initial load
duke
parents:
diff changeset
   878
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   879
     * Check the validity of the given Source or Output File encoding on this
06bc494ca11e Initial load
duke
parents:
diff changeset
   880
     * platform.
06bc494ca11e Initial load
duke
parents:
diff changeset
   881
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   882
     * @param docencoding output file encoding.
06bc494ca11e Initial load
duke
parents:
diff changeset
   883
     * @param reporter    used to report errors.
06bc494ca11e Initial load
duke
parents:
diff changeset
   884
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   885
    private boolean checkOutputFileEncoding(String docencoding) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   886
        OutputStream ost= new ByteArrayOutputStream();
06bc494ca11e Initial load
duke
parents:
diff changeset
   887
        OutputStreamWriter osw = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   888
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
            osw = new OutputStreamWriter(ost, docencoding);
06bc494ca11e Initial load
duke
parents:
diff changeset
   890
        } catch (UnsupportedEncodingException exc) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   891
            reporter.print(ERROR, getText("doclet.Encoding_not_supported", docencoding));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   892
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
        } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
   894
            try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
                if (osw != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   896
                    osw.close();
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
            } catch (IOException exc) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   902
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
06bc494ca11e Initial load
duke
parents:
diff changeset
   904
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
     * Return true if the given doc-file subdirectory should be excluded and
06bc494ca11e Initial load
duke
parents:
diff changeset
   906
     * false otherwise.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   907
     *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
     * @param docfilesubdir the doc-files subdirectory to check.
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   909
     * @return true if the directory is excluded.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   910
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
    public boolean shouldExcludeDocFileDir(String docfilesubdir){
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   912
        return excludedDocFileDirs.contains(docfilesubdir);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   916
     * Return true if the given qualifier should be excluded and false otherwise.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   917
     *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   918
     * @param qualifier the qualifier to check.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   919
     * @return true if the qualifier should be excluded
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   920
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
    public boolean shouldExcludeQualifier(String qualifier){
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
        if (excludedQualifiers.contains("all") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
            excludedQualifiers.contains(qualifier) ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   924
            excludedQualifiers.contains(qualifier + ".*")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   926
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   927
            int index = -1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   928
            while ((index = qualifier.indexOf(".", index + 1)) != -1) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
                if (excludedQualifiers.contains(qualifier.substring(0, index + 1) + "*")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   930
                    return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   931
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   934
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   936
06bc494ca11e Initial load
duke
parents:
diff changeset
   937
    /**
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   938
     * Return the qualified name of the Element if its qualifier is not excluded.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   939
     * Otherwise return the unqualified Element name.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   940
     *
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   941
     * @param te the TypeElement to check.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   942
     * @return the class name
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   943
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   944
    public String getClassName(TypeElement te) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   945
        PackageElement pkg = utils.containingPackage(te);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   946
        return shouldExcludeQualifier(utils.getPackageName(pkg))
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   947
                ? utils.getSimpleName(te)
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
   948
                : utils.getFullyQualifiedName(te);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   949
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   950
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   951
    /**
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   952
     * Convenience method to obtain a resource from the doclet's
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   953
     * {@link Resources resources}.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   954
     * Equivalent to <code>getResources.getText(key);</code>.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   955
     *
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   956
     * @param key the key for the desired string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   957
     * @return the string for the given key
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   958
     * @throws MissingResourceException if the key is not found in either
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   959
     *  bundle.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   960
     */
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   961
    public abstract String getText(String key);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   962
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   963
    /**
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   964
     * Convenience method to obtain a resource from the doclet's
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   965
     * {@link Resources resources}.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   966
     * Equivalent to <code>getResources.getText(key, args);</code>.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
   967
     *
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   968
     * @param key the key for the desired string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   969
     * @param args values to be substituted into the resulting string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   970
     * @return the string for the given key
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   971
     * @throws MissingResourceException if the key is not found in either
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   972
     *  bundle.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   973
     */
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   974
    public abstract String getText(String key, String... args);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   976
    /**
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   977
     * Convenience method to obtain a resource from the doclet's
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   978
     * {@link Resources resources} as a {@code Content} object.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   979
     *
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   980
     * @param key the key for the desired string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   981
     * @return a content tree for the text
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   982
     */
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   983
    public abstract Content getContent(String key);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   985
    /**
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   986
     * Convenience method to obtain a resource from the doclet's
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   987
     * {@link Resources resources} as a {@code Content} object.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   988
     *
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   989
     * @param key the key for the desired string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   990
     * @param o   string or content argument added to configuration text
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   991
     * @return a content tree for the text
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   992
     */
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   993
    public abstract Content getContent(String key, Object o);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   994
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   995
    /**
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   996
     * Convenience method to obtain a resource from the doclet's
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   997
     * {@link Resources resources} as a {@code Content} object.
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   998
     *
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
   999
     * @param key the key for the desired string
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1000
     * @param o1 resource argument
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1001
     * @param o2 resource argument
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1002
     * @return a content tree for the text
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1003
     */
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1004
    public abstract Content getContent(String key, Object o1, Object o2);
17563
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1005
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1006
    /**
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1007
     * Get the configuration string as a content.
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1008
     *
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1009
     * @param key the key for the desired string
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1010
     * @param o0  string or content argument added to configuration text
17563
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1011
     * @param o1  string or content argument added to configuration text
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1012
     * @param o2  string or content argument added to configuration text
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1013
     * @return a content tree for the text
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1014
     */
40303
96a1226aca18 8160697: HTMLWriter needs perf cleanup
jjg
parents: 39364
diff changeset
  1015
    public abstract Content getContent(String key, Object o0, Object o1, Object o2);
17563
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 16560
diff changeset
  1016
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1017
    /**
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1018
     * Return true if the TypeElement element is getting documented, depending upon
9606
e5a619cb5dd3 6492694: @deprecated tag doesn't work in package-info files.
bpatel
parents: 5520
diff changeset
  1019
     * -nodeprecated option and the deprecation information. Return true if
e5a619cb5dd3 6492694: @deprecated tag doesn't work in package-info files.
bpatel
parents: 5520
diff changeset
  1020
     * -nodeprecated is not used. Return false if -nodeprecated is used and if
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1021
     * either TypeElement element is deprecated or the containing package is deprecated.
9606
e5a619cb5dd3 6492694: @deprecated tag doesn't work in package-info files.
bpatel
parents: 5520
diff changeset
  1022
     *
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1023
     * @param te the TypeElement for which the page generation is checked
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1024
     * @return true if it is a generated doc.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1025
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1026
    public boolean isGeneratedDoc(TypeElement te) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1027
        if (!nodeprecated) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1028
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1029
        }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1030
        return !(utils.isDeprecated(te) || utils.isDeprecated(utils.containingPackage(te)));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1031
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1032
06bc494ca11e Initial load
duke
parents:
diff changeset
  1033
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1034
     * Return the doclet specific instance of a writer factory.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
  1035
     *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1036
     * @return the {@link WriterFactory} for the doclet.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1037
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
  1038
    public abstract WriterFactory getWriterFactory();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1039
06bc494ca11e Initial load
duke
parents:
diff changeset
  1040
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
  1041
     * Return the input stream to the builder XML.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1042
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
  1043
     * @return the input steam to the builder XML.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
  1044
     * @throws DocFileIOException when the given XML file cannot be found or opened.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1045
     */
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
  1046
    public InputStream getBuilderXML() throws DocFileIOException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1047
        return builderXMLPath == null ?
45417
f7479ee8de69 8177848: Rename Configuration(Impl) classes
ksrini
parents: 45157
diff changeset
  1048
            BaseConfiguration.class.getResourceAsStream(DEFAULT_BUILDER_XML) :
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14361
diff changeset
  1049
            DocFile.createFileForInput(this, builderXMLPath).openInputStream();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1050
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1051
06bc494ca11e Initial load
duke
parents:
diff changeset
  1052
    /**
1863
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1789
diff changeset
  1053
     * Return the Locale for this document.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
  1054
     *
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1055
     * @return the current locale
1863
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1789
diff changeset
  1056
     */
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1789
diff changeset
  1057
    public abstract Locale getLocale();
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1789
diff changeset
  1058
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1789
diff changeset
  1059
    /**
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1060
     * Return the path of the overview file and null if it does not exist.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1061
     *
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1062
     * @return the path of the overview file.
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
  1063
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1064
    public abstract JavaFileObject getOverviewPath();
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
  1065
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
  1066
    /**
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1067
     * Return the current file manager.
40587
1c355ea550ed 8164130: Simplify doclet IOException handling
jjg
parents: 40508
diff changeset
  1068
     *
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1069
     * @return JavaFileManager
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1070
     */
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1071
    public abstract JavaFileManager getFileManager();
14542
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
  1072
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
  1073
    private void setTabWidth(int n) {
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
  1074
        sourcetab = n;
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
  1075
        tabSpaces = String.format("%" + n + "s", "");
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
  1076
    }
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
  1077
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1078
    public abstract boolean showMessage(DocTreePath path, String key);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1079
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1080
    public abstract boolean showMessage(Element e, String key);
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1081
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1082
    public static abstract class Option implements Doclet.Option, Comparable<Option> {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1083
        private final String[] names;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1084
        private final String parameters;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1085
        private final String description;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1086
        private final int argCount;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1087
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1088
        protected Option(Resources resources, String name, int argCount) {
44815
2a0f6c7033bd 8178830: standard doclet: -javafx option should be unhidden
ksrini
parents: 44460
diff changeset
  1089
            this(resources, null, name, argCount);
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1090
        }
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1091
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1092
        protected Option(Resources resources, String keyBase, String name, int argCount) {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1093
            this.names = name.trim().split("\\s+");
44815
2a0f6c7033bd 8178830: standard doclet: -javafx option should be unhidden
ksrini
parents: 44460
diff changeset
  1094
            if (keyBase == null) {
2a0f6c7033bd 8178830: standard doclet: -javafx option should be unhidden
ksrini
parents: 44460
diff changeset
  1095
                keyBase = "doclet.usage." + names[0].toLowerCase().replaceAll("^-+", "");
2a0f6c7033bd 8178830: standard doclet: -javafx option should be unhidden
ksrini
parents: 44460
diff changeset
  1096
            }
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1097
            String desc = getOptionsMessage(resources, keyBase + ".description");
40314
52f8470ce3e4 8163524: doclet resources doclet.usage.NAME.name are redundant
jjg
parents: 40303
diff changeset
  1098
            if (desc.isEmpty()) {
52f8470ce3e4 8163524: doclet resources doclet.usage.NAME.name are redundant
jjg
parents: 40303
diff changeset
  1099
                this.description = "<MISSING KEY>";
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1100
                this.parameters = "<MISSING KEY>";
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1101
            } else {
40314
52f8470ce3e4 8163524: doclet resources doclet.usage.NAME.name are redundant
jjg
parents: 40303
diff changeset
  1102
                this.description = desc;
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1103
                this.parameters = getOptionsMessage(resources, keyBase + ".parameters");
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1104
            }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1105
            this.argCount = argCount;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1106
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1107
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1108
        protected Option(Resources resources, String name) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1109
            this(resources, name, 0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1110
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1111
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1112
        private String getOptionsMessage(Resources resources, String key) {
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1113
            try {
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1114
                return resources.getText(key);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1115
            } catch (MissingResourceException ignore) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1116
                return "";
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1117
            }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1118
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1119
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1120
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1121
        public String getDescription() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1122
            return description;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1123
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1124
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1125
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1126
        public Option.Kind getKind() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1127
            return Doclet.Option.Kind.STANDARD;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1128
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1129
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1130
        @Override
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1131
        public List<String> getNames() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1132
            return Arrays.asList(names);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1133
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1134
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1135
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1136
        public String getParameters() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1137
            return parameters;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1138
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1139
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1140
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1141
        public String toString() {
43872
b5ce3bc28931 8174839: javadoc crashes with a method which does not override a super.
ksrini
parents: 43261
diff changeset
  1142
            return Arrays.toString(names);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1143
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1144
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1145
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1146
        public int getArgumentCount() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1147
            return argCount;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1148
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1149
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1150
        public boolean matches(String option) {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1151
            for (String name : names) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1152
                boolean matchCase = name.startsWith("--");
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1153
                if (option.startsWith("--") && option.contains("=")) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1154
                    return name.equals(option.substring(option.indexOf("=") + 1));
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1155
                } else if (matchCase) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1156
                    return name.equals(option);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1157
                }
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1158
                return name.toLowerCase().equals(option.toLowerCase());
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1159
            }
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1160
            return false;
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1161
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1162
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1163
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1164
        public int compareTo(Option that) {
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1165
            return this.getNames().get(0).compareTo(that.getNames().get(0));
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1166
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1167
    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1168
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1169
    public abstract class XOption extends Option {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1170
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1171
        public XOption(Resources resources, String prefix, String name, int argCount) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1172
            super(resources, prefix, name, argCount);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1173
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1174
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1175
        public XOption(Resources resources, String name, int argCount) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1176
            super(resources, name, argCount);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1177
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1178
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1179
        public XOption(Resources resources, String name) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1180
            this(resources, name, 0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1181
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1182
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1183
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1184
        public Option.Kind getKind() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1185
            return Doclet.Option.Kind.EXTENDED;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1186
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1187
    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1188
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1189
    public abstract class Hidden extends Option {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1190
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1191
        public Hidden(Resources resources, String name, int argCount) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1192
            super(resources, name, argCount);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1193
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1194
41252
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1195
        public Hidden(Resources resources, String name) {
058d83c9b1c7 8166144: New javadoc options don't conform to JEP 293 (GNU style options)
jjg
parents: 40587
diff changeset
  1196
            this(resources, name, 0);
35426
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1197
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1198
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1199
        @Override
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1200
        public Option.Kind getKind() {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1201
            return Doclet.Option.Kind.OTHER;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1202
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1203
    }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1204
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1205
    /*
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1206
     * Stores a pair of Strings.
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1207
     */
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1208
    protected static class GroupContainer {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1209
        final String value1;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1210
        final String value2;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1211
        public GroupContainer(String value1, String value2) {
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1212
            this.value1 = value1;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1213
            this.value2 = value2;
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1214
        }
374342e56a56 8035473: [javadoc] Revamp the existing Doclet APIs
ksrini
parents: 35420
diff changeset
  1215
    }
42277
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1216
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1217
    /*
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1218
     * Splits the elements in a collection to its individual
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1219
     * collection.
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1220
     */
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1221
    static private class Splitter {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1222
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1223
        final Set<ModuleElement> mset = new LinkedHashSet<>();
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1224
        final Set<PackageElement> pset = new LinkedHashSet<>();
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1225
        final Set<TypeElement> tset = new LinkedHashSet<>();
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1226
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1227
        Splitter(DocletEnvironment docEnv, boolean included) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1228
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1229
            Set<? extends Element> inset = included
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1230
                    ? docEnv.getIncludedElements()
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1231
                    : docEnv.getSpecifiedElements();
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1232
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1233
            for (Element e : inset) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1234
                new SimpleElementVisitor9<Void, Void>() {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1235
                    @Override
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1236
                    @DefinedBy(Api.LANGUAGE_MODEL)
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1237
                    public Void visitModule(ModuleElement e, Void p) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1238
                        mset.add(e);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1239
                        return null;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1240
                    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1241
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1242
                    @Override
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1243
                    @DefinedBy(Api.LANGUAGE_MODEL)
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1244
                    public Void visitPackage(PackageElement e, Void p) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1245
                        pset.add(e);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1246
                        return null;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1247
                    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1248
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1249
                    @Override
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1250
                    @DefinedBy(Api.LANGUAGE_MODEL)
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1251
                    public Void visitType(TypeElement e, Void p) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1252
                        tset.add(e);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1253
                        return null;
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1254
                    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1255
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1256
                    @Override
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1257
                    @DefinedBy(Api.LANGUAGE_MODEL)
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1258
                    protected Void defaultAction(Element e, Void p) {
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1259
                        throw new AssertionError("unexpected element: " + e);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1260
                    }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1261
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1262
                }.visit(e);
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1263
            }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1264
        }
2668b0bc7ad7 8164316: Refine the Doclet APIs
ksrini
parents: 41633
diff changeset
  1265
    }
43261
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1266
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1267
    /**
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1268
     * Returns whether or not to allow JavaScript in comments.
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1269
     * Default is off; can be set true from a command line option.
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1270
     * @return the allowScriptInComments
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1271
     */
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1272
    public boolean isAllowScriptInComments() {
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1273
        return allowScriptInComments;
d377e97291d8 8138725: Add options for Javadoc generation
jjg
parents: 42277
diff changeset
  1274
    }
44460
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1275
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1276
    public VisibleMemberMap getVisibleMemberMap(TypeElement te, VisibleMemberMap.Kind kind) {
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1277
        EnumMap<Kind, Reference<VisibleMemberMap>> cacheMap = typeElementMemberCache
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1278
                .computeIfAbsent(te, k -> new EnumMap<>(VisibleMemberMap.Kind.class));
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1279
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1280
        Reference<VisibleMemberMap> vmapRef = cacheMap.get(kind);
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1281
        // recompute, if referent has been garbage collected
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1282
        VisibleMemberMap vMap = vmapRef == null ? null : vmapRef.get();
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1283
        if (vMap == null) {
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1284
            vMap = new VisibleMemberMap(te, kind, this);
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1285
            cacheMap.put(kind, new SoftReference<>(vMap));
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1286
        }
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1287
        return vMap;
9adfc635dd7b 8177567: cache VisibleMemberMap
ksrini
parents: 44388
diff changeset
  1288
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1289
}