View Javadoc
1   /*
2    * Copyright (c) 2003, 2013, 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   */
25  
26  package com.sun.tools.doclets.internal.toolkit.builders;
27  
28  import java.util.HashSet;
29  import java.util.Set;
30  
31  import com.sun.javadoc.*;
32  import com.sun.tools.javac.jvm.Profile;
33  import com.sun.tools.doclets.internal.toolkit.*;
34  import com.sun.tools.doclets.internal.toolkit.util.*;
35  
36  /**
37   * The factory for constructing builders.
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   */
47  
48  public class BuilderFactory {
49  
50      /**
51       * The current configuration of the doclet.
52       */
53      private final Configuration configuration;
54  
55      /**
56       * The factory to retrieve the required writers from.
57       */
58      private final WriterFactory writerFactory;
59  
60      private final AbstractBuilder.Context context;
61  
62      /**
63       * Construct a builder factory using the given configuration.
64       * @param configuration the configuration for the current doclet
65       * being executed.
66       */
67      public BuilderFactory (Configuration configuration) {
68          this.configuration = configuration;
69          this.writerFactory = configuration.getWriterFactory();
70  
71          Set<String> containingPackagesSeen = new HashSet<String>();
72          context = new AbstractBuilder.Context(configuration, containingPackagesSeen,
73                  LayoutParser.getInstance(configuration));
74      }
75  
76      /**
77       * Return the builder that builds the constant summary.
78       * @return the builder that builds the constant summary.
79       */
80      public AbstractBuilder getConstantsSummaryBuider() throws Exception {
81          return ConstantsSummaryBuilder.getInstance(context,
82              writerFactory.getConstantsSummaryWriter());
83      }
84  
85      /**
86       * Return the builder that builds the package summary.
87       *
88       * @param pkg the package being documented.
89       * @param prevPkg the previous package being documented.
90       * @param nextPkg the next package being documented.
91       * @return the builder that builds the constant summary.
92       */
93      public AbstractBuilder getPackageSummaryBuilder(PackageDoc pkg, PackageDoc prevPkg,
94              PackageDoc nextPkg) throws Exception {
95          return PackageSummaryBuilder.getInstance(context, pkg,
96              writerFactory.getPackageSummaryWriter(pkg, prevPkg, nextPkg));
97      }
98  
99      /**
100      * Return the builder that builds the profile summary.
101      *
102      * @param profile the profile being documented.
103      * @param prevProfile the previous profile being documented.
104      * @param nextProfile the next profile being documented.
105      * @return the builder that builds the profile summary.
106      */
107     public AbstractBuilder getProfileSummaryBuilder(Profile profile, Profile prevProfile,
108             Profile nextProfile) throws Exception {
109         return ProfileSummaryBuilder.getInstance(context, profile,
110             writerFactory.getProfileSummaryWriter(profile, prevProfile, nextProfile));
111     }
112 
113     /**
114      * Return the builder that builds the profile package summary.
115      *
116      * @param pkg the profile package being documented.
117      * @param prevPkg the previous profile package being documented.
118      * @param nextPkg the next profile package being documented.
119      * @param profile the profile being documented.
120      * @return the builder that builds the profile package summary.
121      */
122     public AbstractBuilder getProfilePackageSummaryBuilder(PackageDoc pkg, PackageDoc prevPkg,
123             PackageDoc nextPkg, Profile profile) throws Exception {
124         return ProfilePackageSummaryBuilder.getInstance(context, pkg,
125             writerFactory.getProfilePackageSummaryWriter(pkg, prevPkg, nextPkg,
126                 profile), profile);
127     }
128 
129     /**
130      * Return the builder for the class.
131      *
132      * @param classDoc the class being documented.
133      * @param prevClass the previous class that was documented.
134      * @param nextClass the next class being documented.
135      * @param classTree the class tree.
136      * @return the writer for the class.  Return null if this
137      * writer is not supported by the doclet.
138      */
139     public AbstractBuilder getClassBuilder(ClassDoc classDoc,
140             ClassDoc prevClass, ClassDoc nextClass, ClassTree classTree)
141             throws Exception {
142         return ClassBuilder.getInstance(context, classDoc,
143             writerFactory.getClassWriter(classDoc, prevClass, nextClass,
144                 classTree));
145     }
146 
147     /**
148      * Return the builder for the annotation type.
149      *
150      * @param annotationType the annotation type being documented.
151      * @param prevType the previous type that was documented.
152      * @param nextType the next type being documented.
153      * @return the writer for the annotation type.  Return null if this
154      * writer is not supported by the doclet.
155      */
156     public AbstractBuilder getAnnotationTypeBuilder(
157         AnnotationTypeDoc annotationType,
158         Type prevType, Type nextType)
159             throws Exception {
160         return AnnotationTypeBuilder.getInstance(context, annotationType,
161             writerFactory.getAnnotationTypeWriter(annotationType, prevType, nextType));
162     }
163 
164     /**
165      * Return an instance of the method builder for the given class.
166      *
167      * @return an instance of the method builder for the given class.
168      */
169     public AbstractBuilder getMethodBuilder(ClassWriter classWriter)
170            throws Exception {
171         return MethodBuilder.getInstance(context,
172             classWriter.getClassDoc(),
173             writerFactory.getMethodWriter(classWriter));
174     }
175 
176     /**
177      * Return an instance of the annotation type fields builder for the given
178      * class.
179      *
180      * @return an instance of the annotation type field builder for the given
181      *         annotation type.
182      */
183     public AbstractBuilder getAnnotationTypeFieldsBuilder(
184             AnnotationTypeWriter annotationTypeWriter)
185     throws Exception {
186         return AnnotationTypeFieldBuilder.getInstance(context,
187             annotationTypeWriter.getAnnotationTypeDoc(),
188             writerFactory.getAnnotationTypeFieldWriter(
189                 annotationTypeWriter));
190     }
191 
192     /**
193      * Return an instance of the annotation type member builder for the given
194      * class.
195      *
196      * @return an instance of the annotation type member builder for the given
197      *         annotation type.
198      */
199     public AbstractBuilder getAnnotationTypeOptionalMemberBuilder(
200             AnnotationTypeWriter annotationTypeWriter)
201     throws Exception {
202         return AnnotationTypeOptionalMemberBuilder.getInstance(context,
203             annotationTypeWriter.getAnnotationTypeDoc(),
204             writerFactory.getAnnotationTypeOptionalMemberWriter(
205                 annotationTypeWriter));
206     }
207 
208     /**
209      * Return an instance of the annotation type member builder for the given
210      * class.
211      *
212      * @return an instance of the annotation type member builder for the given
213      *         annotation type.
214      */
215     public AbstractBuilder getAnnotationTypeRequiredMemberBuilder(
216             AnnotationTypeWriter annotationTypeWriter)
217     throws Exception {
218         return AnnotationTypeRequiredMemberBuilder.getInstance(context,
219             annotationTypeWriter.getAnnotationTypeDoc(),
220             writerFactory.getAnnotationTypeRequiredMemberWriter(
221                 annotationTypeWriter));
222     }
223 
224     /**
225      * Return an instance of the enum constants builder for the given class.
226      *
227      * @return an instance of the enum constants builder for the given class.
228      */
229     public AbstractBuilder getEnumConstantsBuilder(ClassWriter classWriter)
230             throws Exception {
231         return EnumConstantBuilder.getInstance(context, classWriter.getClassDoc(),
232             writerFactory.getEnumConstantWriter(classWriter));
233     }
234 
235     /**
236      * Return an instance of the field builder for the given class.
237      *
238      * @return an instance of the field builder for the given class.
239      */
240     public AbstractBuilder getFieldBuilder(ClassWriter classWriter)
241             throws Exception {
242         return FieldBuilder.getInstance(context, classWriter.getClassDoc(),
243             writerFactory.getFieldWriter(classWriter));
244     }
245 
246     /**
247      * Return an instance of the property builder for the given class.
248      *
249      * @return an instance of the field builder for the given class.
250      */
251     public AbstractBuilder getPropertyBuilder(ClassWriter classWriter) throws Exception {
252         final PropertyWriter propertyWriter =
253                 writerFactory.getPropertyWriter(classWriter);
254         return PropertyBuilder.getInstance(context,
255                                            classWriter.getClassDoc(),
256                                            propertyWriter);
257     }
258 
259     /**
260      * Return an instance of the constructor builder for the given class.
261      *
262      * @return an instance of the constructor builder for the given class.
263      */
264     public AbstractBuilder getConstructorBuilder(ClassWriter classWriter)
265             throws Exception {
266         return ConstructorBuilder.getInstance(context,
267             classWriter.getClassDoc(),
268             writerFactory.getConstructorWriter(classWriter));
269     }
270 
271     /**
272      * Return an instance of the member summary builder for the given class.
273      *
274      * @return an instance of the member summary builder for the given class.
275      */
276     public AbstractBuilder getMemberSummaryBuilder(ClassWriter classWriter)
277             throws Exception {
278         return MemberSummaryBuilder.getInstance(classWriter, context);
279     }
280 
281     /**
282      * Return an instance of the member summary builder for the given annotation
283      * type.
284      *
285      * @return an instance of the member summary builder for the given
286      *         annotation type.
287      */
288     public AbstractBuilder getMemberSummaryBuilder(
289             AnnotationTypeWriter annotationTypeWriter)
290     throws Exception {
291         return MemberSummaryBuilder.getInstance(annotationTypeWriter, context);
292     }
293 
294     /**
295      * Return the builder that builds the serialized form.
296      *
297      * @return the builder that builds the serialized form.
298      */
299     public AbstractBuilder getSerializedFormBuilder()
300             throws Exception {
301         return SerializedFormBuilder.getInstance(context);
302     }
303 }