Refine search
/** * Return the qualified name of the <code>ClassDoc</code> if it's qualifier is not excluded. Otherwise, * return the unqualified <code>ClassDoc</code> name. * @param cd the <code>ClassDoc</code> to check. */ public String getClassName(ClassDoc cd) { PackageDoc pd = cd.containingPackage(); if (pd != null && shouldExcludeQualifier(cd.containingPackage().name())) { return cd.name(); } else { return cd.qualifiedName(); } }
DirectoryManager.getRelativePath( pkgdoc.name() ) ); this.pkgdoc = pkgdoc; ClassDoc[] content = pkgdoc.allClasses(); for( int i = 0; i < content.length; ++i ) usedClass.qualifiedName() ); if( usingClasses != null ) PackageDoc usingPackage = usingClass.containingPackage(); Set<ClassDoc> usedClasses = usingPackageToUsedClasses.get( usingPackage.name() ); if( usedClasses == null )
/** * Write the annotatation types for the given packageDoc. * * @param packageDoc the package to write annotations for. */ public void writeAnnotationInfo( PackageDoc packageDoc ) { writeAnnotationInfo( packageDoc, packageDoc.annotations() ); }
/** * Return all of the classes specified on the command-line that * belong to the given package. * @param packageDoc the package to return the classes for. */ public ClassDoc[] allClasses(PackageDoc pkgDoc) { return pkgDoc.isIncluded() ? pkgDoc.allClasses() : getArray(allClasses, Util.getPackageName(pkgDoc)); }
protected Package parsePackage(PackageDoc packageDoc) { Package packageNode = objectFactory.createPackage(); packageNode.setName(packageDoc.name()); String comment = packageDoc.commentText(); if (comment.length() > 0) { packageNode.setComment(comment); } for (Tag tag : packageDoc.tags()) { packageNode.getTag().add(parseTag(tag)); } return packageNode; }
/** * Return true if the given package has constant fields to document. * * @param pkg the package being checked. * @return true if the given package has constant fields to document. */ private boolean hasConstantField(PackageDoc pkg) { ClassDoc[] classes; if (pkg.name().length() > 0) { classes = pkg.allClasses(); } else { classes = configuration.classDocCatalog.allClasses( DocletConstants.DEFAULT_PACKAGE_NAME); } boolean found = false; for (int j = 0; j < classes.length; j++){ if (classes[j].isIncluded() && hasConstantField(classes[j])) { found = true; } } return found; }
if (isFiltered(args)) { if (methodName.equals("methods")) { return filter(((ClassDoc) target).methods(true), MethodDoc.class); } else if (methodName.equals("fields")) { return filter(((ClassDoc) target).fields(true), FieldDoc.class); } else if (methodName.equals("innerClasses")) { return filter(((ClassDoc) target).innerClasses(true), ClassDoc.class); } else if (methodName.equals("constructors")) { return filter(((ClassDoc) target).constructors(true), ConstructorDoc.class); if (methodName.equals("allClasses")) { if (isFiltered(args)) { return filter(((PackageDoc) target).allClasses(true), ClassDoc.class); } else { return filter(((PackageDoc) target).allClasses(), ClassDoc.class); return filter(((PackageDoc) target).annotationTypes(), AnnotationTypeDoc.class); } else if (methodName.equals("enums")) { return filter(((PackageDoc) target).enums(), ClassDoc.class); } else if (methodName.equals("errors")) { return filter(((PackageDoc) target).errors(), ClassDoc.class); } else if (methodName.equals("exceptions")) { return filter(((PackageDoc) target).exceptions(), ClassDoc.class); } else if (methodName.equals("interfaces")) { return filter(((PackageDoc) target).interfaces(), ClassDoc.class); } else if (methodName.equals("ordinaryClasses")) { return filter(((PackageDoc) target).ordinaryClasses(), ClassDoc.class);
/** * @return "com.acme.pkg.Outer$Inner$Inner2" */ public static String className(ClassDoc classDoc) { // "Outer.Inner.Inner2" => "Outer$Inner$Inner2" String name = classDoc.name().replace('.', '$'); String packageName = classDoc.containingPackage().name(); return packageName.isEmpty() ? name : packageName + '.' + name; } }
/** * Add class listing for all the classes in this package. Divide class * listing as per the class kind and generate separate listing for * Classes, Interfaces, Exceptions and Errors. * * @param contentTree the content tree to which the listing will be added * @param profileValue the value of the profile being documented */ protected void addClassListing(Content contentTree, int profileValue) { if (packageDoc.isIncluded()) { addClassKindListing(packageDoc.interfaces(), getResource("doclet.Interfaces"), contentTree, profileValue); addClassKindListing(packageDoc.ordinaryClasses(), getResource("doclet.Classes"), contentTree, profileValue); addClassKindListing(packageDoc.enums(), getResource("doclet.Enums"), contentTree, profileValue); addClassKindListing(packageDoc.exceptions(), getResource("doclet.Exceptions"), contentTree, profileValue); addClassKindListing(packageDoc.errors(), getResource("doclet.Errors"), contentTree, profileValue); addClassKindListing(packageDoc.annotationTypes(), getResource("doclet.AnnotationTypes"), contentTree, profileValue); } }
/** * {@inheritDoc} */ public void writeConstantMembersHeader(ClassDoc cd) { //generate links backward only to public classes. String classlink = (cd.isPublic() || cd.isProtected())? getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY, cd, false)) : cd.qualifiedName(); String name = cd.containingPackage().name(); if (name.length() > 0) { writeClassName(name + "." + classlink); } else { writeClassName(classlink); } }
/** * Get the name of the package, this class is in. * * @param cd ClassDoc. */ public String getPkgName(ClassDoc cd) { String pkgName = cd.containingPackage().name(); if (pkgName.length() > 0) { pkgName += "."; return pkgName; } return ""; }
public boolean matches(String name) { for (ClassDoc cd : packageDoc.allClasses()) { if (cd.qualifiedName().equals(name)) return true; } return false; }
/** * Given a package, return it's name. * @param packageDoc the package to check. * @return the name of the given package. */ public static String getPackageName(PackageDoc packageDoc) { return packageDoc == null || packageDoc.name().length() == 0 ? DocletConstants.DEFAULT_PACKAGE_NAME : packageDoc.name(); }
/** * Build the package serialized for for the current package being processed. */ public void buildPackageSerializedForm(List<?> elements) { String foo = currentPackage.name(); ClassDoc[] classes = currentPackage.allClasses(false); if (classes == null || classes.length == 0) { return; } if (!serialInclude(currentPackage)) { return; } if (!serialClassFoundToDocument(classes)) { return; } build(elements); }
public void buildClassSerializedForm(List<?> elements) { ClassDoc[] classes = currentPackage.allClasses(false); Arrays.sort(classes); for (int j = 0; j < classes.length; j++) { currentClass = classes[j]; fieldWriter = writer.getSerialFieldWriter(currentClass); methodWriter = writer.getSerialMethodWriter(currentClass); if(currentClass.isClass() && currentClass.isSerializable()) { if(!serialClassInclude(currentClass)) { continue; } build(elements); } } }
/** * Convert the Classes in the given Package to an HTML. * @param configuration the configuration. * @param pd the Package to convert. * @param outputdir the name of the directory to output to. */ public static void convertPackage(Configuration configuration, PackageDoc pd, String outputdir) { if (pd == null || outputdir == null) { return; } String classOutputdir = getPackageOutputDir(outputdir, pd); ClassDoc[] cds = pd.allClasses(); for (int i = 0; i < cds.length; i++) { convertClass(configuration, cds[i], classOutputdir); } }
/** * Build the summary for the classes in this package. */ public void buildClassSummary() { String classTableSummary = configuration.getText("doclet.Member_Table_Summary", configuration.getText("doclet.Class_Summary"), configuration.getText("doclet.classes")); String[] classTableHeader = new String[] { configuration.getText("doclet.Class"), configuration.getText("doclet.Description") }; ClassDoc[] classes = packageDoc.isIncluded() ? packageDoc.ordinaryClasses() : configuration.classDocCatalog.ordinaryClasses( Util.getPackageName(packageDoc)); if (classes.length > 0) { packageWriter.writeClassesSummary( classes, configuration.getText("doclet.Class_Summary"), classTableSummary, classTableHeader); } }
/** * Build the summary for the errors in this package. */ public void buildErrorSummary() { String errorTableSummary = configuration.getText("doclet.Member_Table_Summary", configuration.getText("doclet.Error_Summary"), configuration.getText("doclet.errors")); String[] errorTableHeader = new String[] { configuration.getText("doclet.Error"), configuration.getText("doclet.Description") }; ClassDoc[] errors = packageDoc.isIncluded() ? packageDoc.errors() : configuration.classDocCatalog.errors( Util.getPackageName(packageDoc)); if (errors.length > 0) { packageWriter.writeClassesSummary( errors, configuration.getText("doclet.Error_Summary"), errorTableSummary, errorTableHeader); } }
/** * Build the summary for the enums in this package. */ public void buildAnnotationTypeSummary() { String annotationtypeTableSummary = configuration.getText("doclet.Member_Table_Summary", configuration.getText("doclet.Annotation_Types_Summary"), configuration.getText("doclet.annotationtypes")); String[] annotationtypeTableHeader = new String[] { configuration.getText("doclet.AnnotationType"), configuration.getText("doclet.Description") }; ClassDoc[] annotationTypes = packageDoc.isIncluded() ? packageDoc.annotationTypes() : configuration.classDocCatalog.annotationTypes( Util.getPackageName(packageDoc)); if (annotationTypes.length > 0) { packageWriter.writeClassesSummary( annotationTypes, configuration.getText("doclet.Annotation_Types_Summary"), annotationtypeTableSummary, annotationtypeTableHeader); } }
/** * Build the summary for the exceptions in this package. */ public void buildExceptionSummary() { String exceptionTableSummary = configuration.getText("doclet.Member_Table_Summary", configuration.getText("doclet.Exception_Summary"), configuration.getText("doclet.exceptions")); String[] exceptionTableHeader = new String[] { configuration.getText("doclet.Exception"), configuration.getText("doclet.Description") }; ClassDoc[] exceptions = packageDoc.isIncluded() ? packageDoc.exceptions() : configuration.classDocCatalog.exceptions( Util.getPackageName(packageDoc)); if (exceptions.length > 0) { packageWriter.writeClassesSummary( exceptions, configuration.getText("doclet.Exception_Summary"), exceptionTableSummary, exceptionTableHeader); } }