jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassDocCatalog.java@400a4e8accd3

     1 /*

     2  * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package com.sun.tools.doclets.internal.toolkit.util;

    28 import java.util.*;

    29 import com.sun.javadoc.*;

    30 import com.sun.tools.doclets.internal.toolkit.Configuration;

    32 /**

    33  * This class acts as an artificial PackageDoc for classes specified

    34  * on the command line when running Javadoc.  For example, if you

    35  * specify several classes from package java.lang, this class will catalog

    36  * those classes so that we can retrieve all of the classes from a particular

    37  * package later.

    38  *

    39  *  <p><b>This is NOT part of any supported API.

    40  *  If you write code that depends on this, you do so at your own risk.

    41  *  This code and its internal interfaces are subject to change or

    42  *  deletion without notice.</b>

    43  *

    44  * @author Jamie Ho

    45  * @since 1.4

    46  */

    48  public class ClassDocCatalog {

    50      /**

    51       * Stores the set of packages that the classes specified on the command line

    52       * belong to.  Note that the default package is "".

    53       */

    54      private Set<String> packageSet;

    57      /**

    58       * Stores all classes for each package

    59       */

    60      private Map<String,Set<ClassDoc>> allClasses;

    62      /**

    63       * Stores ordinary classes (excluding Exceptions and Errors) for each

    64       * package

    65       */

    66      private Map<String,Set<ClassDoc>> ordinaryClasses;

    68      /**

    69       * Stores exceptions for each package

    70       */

    71      private Map<String,Set<ClassDoc>> exceptions;

    73     /**

    74      * Stores enums for each package.

    75      */

    76     private Map<String,Set<ClassDoc>> enums;

    78     /**

    79      * Stores annotation types for each package.

    80      */

    81     private Map<String,Set<ClassDoc>> annotationTypes;

    83      /**

    84       * Stores errors for each package

    85       */

    86      private Map<String,Set<ClassDoc>> errors;

    88      /**

    89       * Stores interfaces for each package

    90       */

    91      private Map<String,Set<ClassDoc>> interfaces;

    93      private Configuration configuration;

    95      /**

    96       * Construct a new ClassDocCatalog.

    97       *

    98       * @param classdocs the array of ClassDocs to catalog

    99       */

   100      public ClassDocCatalog (ClassDoc[] classdocs, Configuration config) {

   101          init();

   102          this.configuration = config;

   103          for (int i = 0; i < classdocs.length; i++) {

   104              addClassDoc(classdocs[i]);

   105          }

   106      }

   108      /**

   109       * Construct a new ClassDocCatalog.

   110       *

   111       */

   112      public ClassDocCatalog () {

   113          init();

   114      }

   116      private void init() {

   117          allClasses = new HashMap<String,Set<ClassDoc>>();

   118          ordinaryClasses = new HashMap<String,Set<ClassDoc>>();

   119          exceptions = new HashMap<String,Set<ClassDoc>>();

   120          enums = new HashMap<String,Set<ClassDoc>>();

   121          annotationTypes = new HashMap<String,Set<ClassDoc>>();

   122          errors = new HashMap<String,Set<ClassDoc>>();

   123          interfaces = new HashMap<String,Set<ClassDoc>>();

   124          packageSet = new HashSet<String>();

   125      }

   127      /**

   128       * Add the given class to the catalog.

   129       * @param classdoc the ClassDoc to add to the catelog.

   130       */

   131       public void addClassDoc(ClassDoc classdoc) {

   132         if (classdoc == null) {

   133             return;

   134         }

   135         addClass(classdoc, allClasses);

   136         if (classdoc.isOrdinaryClass()) {

   137             addClass(classdoc, ordinaryClasses);

   138         } else if (classdoc.isException()) {

   139             addClass(classdoc, exceptions);

   140         } else if (classdoc.isEnum()) {

   141             addClass(classdoc, enums);

   142         } else if (classdoc.isAnnotationType()) {

   143             addClass(classdoc, annotationTypes);

   144         } else if (classdoc.isError()) {

   145             addClass(classdoc, errors);

   146         } else if (classdoc.isInterface()) {

   147             addClass(classdoc, interfaces);

   148         }

   149       }

   151       /**

   152        * Add the given class to the given map.

   153        * @param classdoc the ClassDoc to add to the catelog.

   154        * @param map the Map to add the ClassDoc to.

   155        */

   156       private void addClass(ClassDoc classdoc, Map<String,Set<ClassDoc>> map) {

   158           PackageDoc pkg = classdoc.containingPackage();

   159           if (pkg.isIncluded() || (configuration.nodeprecated && Util.isDeprecated(pkg))) {

   160               //No need to catalog this class if it's package is

   161               //included on the command line or if -nodeprecated option is set

   162               // and the containing package is marked as deprecated.

   163               return;

   164           }

   165           String key = Util.getPackageName(pkg);

   166           Set<ClassDoc> s = map.get(key);

   167           if (s == null) {

   168               packageSet.add(key);

   169               s = new HashSet<ClassDoc>();

   170           }

   171           s.add(classdoc);

   172           map.put(key, s);

   174       }

   176       private ClassDoc[] getArray(Map<String,Set<ClassDoc>> m, String key) {

   177           Set<ClassDoc> s = m.get(key);

   178           if (s == null) {

   179               return new ClassDoc[] {};

   180           } else {

   181               return s.toArray(new ClassDoc[] {});

   182           }

   183       }

   185       /**

   186        * Return all of the classes specified on the command-line that

   187        * belong to the given package.

   188        * @param pkgDoc the package to return the classes for.

   189        */

   190       public ClassDoc[] allClasses(PackageDoc pkgDoc) {

   191           return pkgDoc.isIncluded() ?

   192                 pkgDoc.allClasses() :

   193                 getArray(allClasses, Util.getPackageName(pkgDoc));

   194       }

   196       /**

   197        * Return all of the classes specified on the command-line that

   198        * belong to the given package.

   199        * @param packageName the name of the package specified on the

   200        * command-line.

   201        */

   202       public ClassDoc[] allClasses(String packageName) {

   203           return getArray(allClasses, packageName);

   204       }

   206      /**

   207       * Return the array of package names that this catalog stores

   208       * ClassDocs for.

   209       */

   210      public String[] packageNames() {

   211          return packageSet.toArray(new String[] {});

   212      }

   214      /**

   215       * Return true if the given package is known to this catalog.

   216       * @param packageName the name to check.

   217       * @return true if this catalog has any information about

   218       * classes in the given package.

   219       */

   220      public boolean isKnownPackage(String packageName) {

   221          return packageSet.contains(packageName);

   222      }

   225       /**

   226        * Return all of the errors specified on the command-line

   227        * that belong to the given package.

   228        * @param packageName the name of the package specified on the

   229        * command-line.

   230        */

   231       public ClassDoc[] errors(String packageName) {

   232           return getArray(errors, packageName);

   233       }

   235       /**

   236        * Return all of the exceptions specified on the command-line

   237        * that belong to the given package.

   238        * @param packageName the name of the package specified on the

   239        * command-line.

   240        */

   241       public ClassDoc[] exceptions(String packageName) {

   242           return getArray(exceptions, packageName);

   243       }

   245       /**

   246        * Return all of the enums specified on the command-line

   247        * that belong to the given package.

   248        * @param packageName the name of the package specified on the

   249        * command-line.

   250        */

   251       public ClassDoc[] enums(String packageName) {

   252           return getArray(enums, packageName);

   253       }

   255       /**

   256        * Return all of the annotation types specified on the command-line

   257        * that belong to the given package.

   258        * @param packageName the name of the package specified on the

   259        * command-line.

   260        */

   261       public ClassDoc[] annotationTypes(String packageName) {

   262           return getArray(annotationTypes, packageName);

   263       }

   265       /**

   266        * Return all of the interfaces specified on the command-line

   267        * that belong to the given package.

   268        * @param packageName the name of the package specified on the

   269        * command-line.

   270        */

   271       public ClassDoc[] interfaces(String packageName) {

   272           return getArray(interfaces, packageName);

   273       }

   275       /**

   276        * Return all of the ordinary classes specified on the command-line

   277        * that belong to the given package.

   278        * @param packageName the name of the package specified on the

   279        * command-line.

   280        */

   281       public ClassDoc[] ordinaryClasses(String packageName) {

   282           return getArray(ordinaryClasses, packageName);

   283       }

   284 }

Mercurial > jdk8-mips64-public > langtools / file revision

src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassDocCatalog.java@400a4e8accd3

src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassDocCatalog.java