41 import jdk.javadoc.internal.doclets.toolkit.util.DocFileIOException;
42 import jdk.javadoc.internal.doclets.toolkit.util.DocPath;
43 import jdk.javadoc.internal.doclets.toolkit.util.DocPaths;
44
45 /**
46 * Generate package usage information.
47 *
48 * <p><b>This is NOT part of any supported API.
49 * If you write code that depends on this, you do so at your own risk.
50 * This code and its internal interfaces are subject to change or
51 * deletion without notice.</b>
52 *
53 * @author Robert G. Field
54 * @author Bhavesh Patel (Modified)
55 */
56 public class PackageUseWriter extends SubWriterHolderWriter {
57
58 final PackageElement packageElement;
59 final SortedMap<String, Set<TypeElement>> usingPackageToUsedClasses = new TreeMap<>();
60 protected HtmlTree mainTree = HtmlTree.MAIN();
61
62 /**
63 * Constructor.
64 *
65 * @param filename the file to be generated.
66 */
67 public PackageUseWriter(HtmlConfiguration configuration,
68 ClassUseMapper mapper, DocPath filename,
69 PackageElement pkgElement) {
70 super(configuration, DocPath.forPackage(pkgElement).resolve(filename));
71 this.packageElement = pkgElement;
72
73 // by examining all classes in this package, find what packages
74 // use these classes - produce a map between using package and
75 // used classes.
76 for (TypeElement usedClass : utils.getEnclosedTypeElements(pkgElement)) {
77 Set<TypeElement> usingClasses = mapper.classToClass.get(usedClass);
78 if (usingClasses != null) {
79 for (TypeElement usingClass : usingClasses) {
80 PackageElement usingPackage = utils.containingPackage(usingClass);
81 Set<TypeElement> usedClasses = usingPackageToUsedClasses
82 .get(utils.getPackageName(usingPackage));
83 if (usedClasses == null) {
84 usedClasses = new TreeSet<>(utils.makeGeneralPurposeComparator());
85 usingPackageToUsedClasses.put(utils.getPackageName(usingPackage),
86 usedClasses);
87 }
88 usedClasses.add(usedClass);
89 }
90 }
91 }
92 }
93
94 /**
95 * Generate a class page.
96 *
97 * @param configuration the current configuration of the doclet.
98 * @param mapper the mapping of the class usage.
99 * @param pkgElement the package being documented.
100 * @throws DocFileIOException if there is a problem generating the package use page
101 */
102 public static void generate(HtmlConfiguration configuration,
103 ClassUseMapper mapper, PackageElement pkgElement)
104 throws DocFileIOException {
105 DocPath filename = DocPaths.PACKAGE_USE;
106 PackageUseWriter pkgusegen = new PackageUseWriter(configuration, mapper, filename, pkgElement);
107 pkgusegen.generatePackageUseFile();
108 }
109
110 /**
111 * Generate the package use list.
146 HtmlTree ul = new HtmlTree(HtmlTag.UL);
147 ul.addStyle(HtmlStyle.blockList);
148 if (configuration.packages.size() > 1) {
149 addPackageList(ul);
150 }
151 addClassList(ul);
152 contentTree.addContent(ul);
153 }
154
155 /**
156 * Add the list of packages that use the given package.
157 *
158 * @param contentTree the content tree to which the package list will be added
159 */
160 protected void addPackageList(Content contentTree) {
161 Content caption = getTableCaption(configuration.getContent(
162 "doclet.ClassUse_Packages.that.use.0",
163 getPackageLink(packageElement, utils.getPackageName(packageElement))));
164 Content table = (configuration.isOutputHtml5())
165 ? HtmlTree.TABLE(HtmlStyle.useSummary, caption)
166 : HtmlTree.TABLE(HtmlStyle.useSummary, useTableSummary, caption);
167 table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
168 Content tbody = new HtmlTree(HtmlTag.TBODY);
169 boolean altColor = true;
170 for (String pkgname: usingPackageToUsedClasses.keySet()) {
171 PackageElement pkg = utils.elementUtils.getPackageElement(pkgname);
172 HtmlTree tr = new HtmlTree(HtmlTag.TR);
173 tr.addStyle(altColor ? HtmlStyle.altColor : HtmlStyle.rowColor);
174 altColor = !altColor;
175 addPackageUse(pkg, tr);
176 tbody.addContent(tr);
177 }
178 table.addContent(tbody);
179 Content li = HtmlTree.LI(HtmlStyle.blockList, table);
180 contentTree.addContent(li);
181 }
182
183 /**
184 * Add the list of classes that use the given package.
185 *
186 * @param contentTree the content tree to which the class list will be added
187 */
188 protected void addClassList(Content contentTree) {
189 List<String> classTableHeader = Arrays.asList(
190 resources.getText("doclet.Class"), resources.getText("doclet.Description"));
191 for (String packageName : usingPackageToUsedClasses.keySet()) {
192 PackageElement usingPackage = utils.elementUtils.getPackageElement(packageName);
193 HtmlTree li = new HtmlTree(HtmlTag.LI);
194 li.addStyle(HtmlStyle.blockList);
195 if (usingPackage != null) {
196 li.addContent(getMarkerAnchor(utils.getPackageName(usingPackage)));
197 }
198 String tableSummary = configuration.getText("doclet.Use_Table_Summary",
199 configuration.getText("doclet.classes"));
200 Content caption = getTableCaption(configuration.getContent(
201 "doclet.ClassUse_Classes.in.0.used.by.1",
202 getPackageLink(packageElement, utils.getPackageName(packageElement)),
203 getPackageLink(usingPackage, utils.getPackageName(usingPackage))));
204 Content table = (configuration.isOutputHtml5())
205 ? HtmlTree.TABLE(HtmlStyle.useSummary, caption)
206 : HtmlTree.TABLE(HtmlStyle.useSummary, tableSummary, caption);
207 table.addContent(getSummaryTableHeader(classTableHeader, "col"));
208 Content tbody = new HtmlTree(HtmlTag.TBODY);
209 boolean altColor = true;
210 for (TypeElement te : usingPackageToUsedClasses.get(packageName)) {
211 HtmlTree tr = new HtmlTree(HtmlTag.TR);
212 tr.addStyle(altColor ? HtmlStyle.altColor : HtmlStyle.rowColor);
213 altColor = !altColor;
214 addClassRow(te, usingPackage, tr);
215 tbody.addContent(tr);
216 }
217 table.addContent(tbody);
218 li.addContent(table);
219 contentTree.addContent(li);
220 }
221 }
222
223 /**
224 * Add a row for the class that uses the given package.
225 *
226 * @param usedClass the class that uses the given package
227 * @param pkg the package to which the class belongs
|
41 import jdk.javadoc.internal.doclets.toolkit.util.DocFileIOException;
42 import jdk.javadoc.internal.doclets.toolkit.util.DocPath;
43 import jdk.javadoc.internal.doclets.toolkit.util.DocPaths;
44
45 /**
46 * Generate package usage information.
47 *
48 * <p><b>This is NOT part of any supported API.
49 * If you write code that depends on this, you do so at your own risk.
50 * This code and its internal interfaces are subject to change or
51 * deletion without notice.</b>
52 *
53 * @author Robert G. Field
54 * @author Bhavesh Patel (Modified)
55 */
56 public class PackageUseWriter extends SubWriterHolderWriter {
57
58 final PackageElement packageElement;
59 final SortedMap<String, Set<TypeElement>> usingPackageToUsedClasses = new TreeMap<>();
60 protected HtmlTree mainTree = HtmlTree.MAIN();
61 final String packageUseTableSummary;
62
63 /**
64 * Constructor.
65 *
66 * @param configuration the configuration
67 * @param mapper a mapper to provide details of where elements are used
68 * @param filename the file to be generated
69 * @param pkgElement the package element to be documented
70 */
71 public PackageUseWriter(HtmlConfiguration configuration,
72 ClassUseMapper mapper, DocPath filename,
73 PackageElement pkgElement) {
74 super(configuration, DocPath.forPackage(pkgElement).resolve(filename));
75 this.packageElement = pkgElement;
76
77 // by examining all classes in this package, find what packages
78 // use these classes - produce a map between using package and
79 // used classes.
80 for (TypeElement usedClass : utils.getEnclosedTypeElements(pkgElement)) {
81 Set<TypeElement> usingClasses = mapper.classToClass.get(usedClass);
82 if (usingClasses != null) {
83 for (TypeElement usingClass : usingClasses) {
84 PackageElement usingPackage = utils.containingPackage(usingClass);
85 Set<TypeElement> usedClasses = usingPackageToUsedClasses
86 .get(utils.getPackageName(usingPackage));
87 if (usedClasses == null) {
88 usedClasses = new TreeSet<>(utils.makeGeneralPurposeComparator());
89 usingPackageToUsedClasses.put(utils.getPackageName(usingPackage),
90 usedClasses);
91 }
92 usedClasses.add(usedClass);
93 }
94 }
95 }
96
97 packageUseTableSummary = configuration.getText("doclet.Use_Table_Summary",
98 configuration.getText("doclet.packages"));
99 }
100
101 /**
102 * Generate a class page.
103 *
104 * @param configuration the current configuration of the doclet.
105 * @param mapper the mapping of the class usage.
106 * @param pkgElement the package being documented.
107 * @throws DocFileIOException if there is a problem generating the package use page
108 */
109 public static void generate(HtmlConfiguration configuration,
110 ClassUseMapper mapper, PackageElement pkgElement)
111 throws DocFileIOException {
112 DocPath filename = DocPaths.PACKAGE_USE;
113 PackageUseWriter pkgusegen = new PackageUseWriter(configuration, mapper, filename, pkgElement);
114 pkgusegen.generatePackageUseFile();
115 }
116
117 /**
118 * Generate the package use list.
153 HtmlTree ul = new HtmlTree(HtmlTag.UL);
154 ul.addStyle(HtmlStyle.blockList);
155 if (configuration.packages.size() > 1) {
156 addPackageList(ul);
157 }
158 addClassList(ul);
159 contentTree.addContent(ul);
160 }
161
162 /**
163 * Add the list of packages that use the given package.
164 *
165 * @param contentTree the content tree to which the package list will be added
166 */
167 protected void addPackageList(Content contentTree) {
168 Content caption = getTableCaption(configuration.getContent(
169 "doclet.ClassUse_Packages.that.use.0",
170 getPackageLink(packageElement, utils.getPackageName(packageElement))));
171 Content table = (configuration.isOutputHtml5())
172 ? HtmlTree.TABLE(HtmlStyle.useSummary, caption)
173 : HtmlTree.TABLE(HtmlStyle.useSummary, packageUseTableSummary, caption);
174 table.addContent(getPackageTableHeader().toContent());
175 Content tbody = new HtmlTree(HtmlTag.TBODY);
176 boolean altColor = true;
177 for (String pkgname: usingPackageToUsedClasses.keySet()) {
178 PackageElement pkg = utils.elementUtils.getPackageElement(pkgname);
179 HtmlTree tr = new HtmlTree(HtmlTag.TR);
180 tr.addStyle(altColor ? HtmlStyle.altColor : HtmlStyle.rowColor);
181 altColor = !altColor;
182 addPackageUse(pkg, tr);
183 tbody.addContent(tr);
184 }
185 table.addContent(tbody);
186 Content li = HtmlTree.LI(HtmlStyle.blockList, table);
187 contentTree.addContent(li);
188 }
189
190 /**
191 * Add the list of classes that use the given package.
192 *
193 * @param contentTree the content tree to which the class list will be added
194 */
195 protected void addClassList(Content contentTree) {
196 TableHeader classTableHeader = new TableHeader(
197 contents.classLabel, contents.descriptionLabel);
198 for (String packageName : usingPackageToUsedClasses.keySet()) {
199 PackageElement usingPackage = utils.elementUtils.getPackageElement(packageName);
200 HtmlTree li = new HtmlTree(HtmlTag.LI);
201 li.addStyle(HtmlStyle.blockList);
202 if (usingPackage != null) {
203 li.addContent(getMarkerAnchor(utils.getPackageName(usingPackage)));
204 }
205 String tableSummary = configuration.getText("doclet.Use_Table_Summary",
206 configuration.getText("doclet.classes"));
207 Content caption = getTableCaption(configuration.getContent(
208 "doclet.ClassUse_Classes.in.0.used.by.1",
209 getPackageLink(packageElement, utils.getPackageName(packageElement)),
210 getPackageLink(usingPackage, utils.getPackageName(usingPackage))));
211 Content table = (configuration.isOutputHtml5())
212 ? HtmlTree.TABLE(HtmlStyle.useSummary, caption)
213 : HtmlTree.TABLE(HtmlStyle.useSummary, tableSummary, caption);
214 table.addContent(classTableHeader.toContent());
215 Content tbody = new HtmlTree(HtmlTag.TBODY);
216 boolean altColor = true;
217 for (TypeElement te : usingPackageToUsedClasses.get(packageName)) {
218 HtmlTree tr = new HtmlTree(HtmlTag.TR);
219 tr.addStyle(altColor ? HtmlStyle.altColor : HtmlStyle.rowColor);
220 altColor = !altColor;
221 addClassRow(te, usingPackage, tr);
222 tbody.addContent(tr);
223 }
224 table.addContent(tbody);
225 li.addContent(table);
226 contentTree.addContent(li);
227 }
228 }
229
230 /**
231 * Add a row for the class that uses the given package.
232 *
233 * @param usedClass the class that uses the given package
234 * @param pkg the package to which the class belongs
|