/**
  * Add deprecated information to the documentation tree
  *
  * @param deprmembers list of deprecated members
  * @param headingKey the caption for the deprecated members table
  * @param tableSummary the summary for the deprecated members table
  * @param tableHeader table headers for the deprecated members table
  * @param contentTree the content tree to which the deprecated members table will be added
  */
 protected void addDeprecatedAPI(
     List<Doc> deprmembers,
     String headingKey,
     String tableSummary,
     String[] tableHeader,
     Content contentTree) {
   if (deprmembers.size() > 0) {
     Content caption = writer.getTableCaption(configuration.getResource(headingKey));
     Content table =
         (configuration.isOutputHtml5())
             ? HtmlTree.TABLE(HtmlStyle.deprecatedSummary, caption)
             : HtmlTree.TABLE(HtmlStyle.deprecatedSummary, tableSummary, caption);
     table.addContent(writer.getSummaryTableHeader(tableHeader, "col"));
     Content tbody = new HtmlTree(HtmlTag.TBODY);
     for (int i = 0; i < deprmembers.size(); i++) {
       ProgramElementDoc member = (ProgramElementDoc) deprmembers.get(i);
       HtmlTree td = HtmlTree.TD(HtmlStyle.colOne, getDeprecatedLink(member));
       if (member.tags("deprecated").length > 0)
         writer.addInlineDeprecatedComment(member, member.tags("deprecated")[0], td);
       HtmlTree tr = HtmlTree.TR(td);
       if (i % 2 == 0) tr.addStyle(HtmlStyle.altColor);
       else tr.addStyle(HtmlStyle.rowColor);
       tbody.addContent(tr);
     }
     table.addContent(tbody);
     Content li = HtmlTree.LI(HtmlStyle.blockList, table);
     Content ul = HtmlTree.UL(HtmlStyle.blockList, li);
     contentTree.addContent(ul);
   }
 }
 /**
  * Add use information to the documentation tree.
  *
  * @param mems list of program elements for which the use information will be added
  * @param heading the section heading
  * @param tableSummary the summary for the use table
  * @param contentTree the content tree to which the use information will be added
  */
 protected void addUseInfo(
     List<? extends ProgramElementDoc> mems,
     Content heading,
     String tableSummary,
     Content contentTree) {
   if (mems == null) {
     return;
   }
   List<? extends ProgramElementDoc> members = mems;
   boolean printedUseTableHeader = false;
   if (members.size() > 0) {
     Content caption = writer.getTableCaption(heading);
     Content table =
         (configuration.isOutputHtml5())
             ? HtmlTree.TABLE(HtmlStyle.useSummary, caption)
             : HtmlTree.TABLE(HtmlStyle.useSummary, tableSummary, caption);
     Content tbody = new HtmlTree(HtmlTag.TBODY);
     Iterator<? extends ProgramElementDoc> it = members.iterator();
     for (int i = 0; it.hasNext(); i++) {
       ProgramElementDoc pgmdoc = it.next();
       ClassDoc cd = pgmdoc.containingClass();
       if (!printedUseTableHeader) {
         table.addContent(writer.getSummaryTableHeader(this.getSummaryTableHeader(pgmdoc), "col"));
         printedUseTableHeader = true;
       }
       HtmlTree tr = new HtmlTree(HtmlTag.TR);
       if (i % 2 == 0) {
         tr.addStyle(HtmlStyle.altColor);
       } else {
         tr.addStyle(HtmlStyle.rowColor);
       }
       HtmlTree tdFirst = new HtmlTree(HtmlTag.TD);
       tdFirst.addStyle(HtmlStyle.colFirst);
       writer.addSummaryType(this, pgmdoc, tdFirst);
       tr.addContent(tdFirst);
       HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
       tdLast.addStyle(HtmlStyle.colLast);
       if (cd != null && !(pgmdoc instanceof ConstructorDoc) && !(pgmdoc instanceof ClassDoc)) {
         HtmlTree name = new HtmlTree(HtmlTag.SPAN);
         name.addStyle(HtmlStyle.typeNameLabel);
         name.addContent(cd.name() + ".");
         tdLast.addContent(name);
       }
       addSummaryLink(
           pgmdoc instanceof ClassDoc ? LinkInfoImpl.Kind.CLASS_USE : LinkInfoImpl.Kind.MEMBER,
           cd,
           pgmdoc,
           tdLast);
       writer.addSummaryLinkComment(this, pgmdoc, tdLast);
       tr.addContent(tdLast);
       tbody.addContent(tr);
     }
     table.addContent(tbody);
     contentTree.addContent(table);
   }
 }
 /**
  * Add the navigation summary link.
  *
  * @param members members to be linked
  * @param visibleMemberMap the visible inherited members map
  * @param liNav the content tree to which the navigation summary link will be added
  */
 protected void addNavSummaryLink(
     List<?> members, VisibleMemberMap visibleMemberMap, Content liNav) {
   if (members.size() > 0) {
     liNav.addContent(getNavSummaryLink(null, true));
     return;
   }
   ClassDoc icd = classdoc.superclass();
   while (icd != null) {
     List<?> inhmembers = visibleMemberMap.getMembersFor(icd);
     if (inhmembers.size() > 0) {
       liNav.addContent(getNavSummaryLink(icd, true));
       return;
     }
     icd = icd.superclass();
   }
   liNav.addContent(getNavSummaryLink(null, false));
 }
Exemple #4
0
 /**
  * Build the field documentation.
  *
  * @param elements the XML elements that specify how to construct this documentation.
  */
 public void buildFieldDoc(List<?> elements) {
   if (writer == null) {
     return;
   }
   for (currentFieldIndex = 0; currentFieldIndex < fields.size(); currentFieldIndex++) {
     build(elements);
   }
 }
 /**
  * Build the method documentation.
  *
  * @param node the XML element that specifies which components to document
  * @param memberDetailsTree the content tree to which the documentation will be added
  */
 public void buildMethodDoc(XMLNode node, Content memberDetailsTree) {
   if (writer == null) {
     return;
   }
   int size = methods.size();
   if (size > 0) {
     Content methodDetailsTree = writer.getMethodDetailsTreeHeader(classDoc, memberDetailsTree);
     for (currentMethodIndex = 0; currentMethodIndex < size; currentMethodIndex++) {
       Content methodDocTree =
           writer.getMethodDocTreeHeader(
               (MethodDoc) methods.get(currentMethodIndex), methodDetailsTree);
       buildChildren(node, methodDocTree);
       methodDetailsTree.addContent(
           writer.getMethodDoc(methodDocTree, (currentMethodIndex == size - 1)));
     }
     memberDetailsTree.addContent(writer.getMethodDetails(methodDetailsTree));
   }
 }
 /**
  * Build the field documentation.
  *
  * @param node the XML element that specifies which components to document
  * @param memberDetailsTree the content tree to which the documentation will be added
  */
 public void buildFieldDoc(XMLNode node, Content memberDetailsTree) {
   if (writer == null) {
     return;
   }
   int size = fields.size();
   if (size > 0) {
     Content fieldDetailsTree = writer.getFieldDetailsTreeHeader(classDoc, memberDetailsTree);
     for (currentFieldIndex = 0; currentFieldIndex < size; currentFieldIndex++) {
       Content fieldDocTree =
           writer.getFieldDocTreeHeader(
               (FieldDoc) fields.get(currentFieldIndex), fieldDetailsTree);
       buildChildren(node, fieldDocTree);
       fieldDetailsTree.addContent(
           writer.getFieldDoc(fieldDocTree, (currentFieldIndex == size - 1)));
     }
     memberDetailsTree.addContent(writer.getFieldDetails(fieldDetailsTree));
   }
 }
Exemple #7
0
 /**
  * Build the enum constant documentation.
  *
  * @param elements the XML elements that specify how to construct this documentation.
  */
 public void buildEnumConstant(List<?> elements) {
   if (writer == null) {
     return;
   }
   for (currentEnumConstantsIndex = 0;
       currentEnumConstantsIndex < enumConstants.size();
       currentEnumConstantsIndex++) {
     build(elements);
   }
 }
  /**
   * Build the comments for the method. Do nothing if {@link Configuration#nocomment} is set to
   * true.
   *
   * @param node the XML element that specifies which components to document
   * @param methodDocTree the content tree to which the documentation will be added
   */
  public void buildMethodComments(XMLNode node, Content methodDocTree) {
    if (!configuration.nocomment) {
      MethodDoc method = (MethodDoc) methods.get(currentMethodIndex);

      if (method.inlineTags().length == 0) {
        DocFinder.Output docs = DocFinder.search(configuration, new DocFinder.Input(method));
        method =
            docs.inlineTags != null && docs.inlineTags.length > 0
                ? (MethodDoc) docs.holder
                : method;
      }
      // NOTE:  When we fix the bug where ClassDoc.interfaceTypes() does
      //       not pass all implemented interfaces, holder will be the
      //       interface type.  For now, it is really the erasure.
      writer.addComments(method.containingClass(), method, methodDocTree);
    }
  }
 /**
  * Add the member summary for the given class.
  *
  * @param classDoc the class that is being documented
  * @param member the member being documented
  * @param firstSentenceTags the first sentence tags to be added to the summary
  * @param tableContents the list of contents to which the documentation will be added
  * @param counter the counter for determining id and style for the table row
  */
 public void addMemberSummary(
     ClassDoc classDoc,
     ProgramElementDoc member,
     Tag[] firstSentenceTags,
     List<Content> tableContents,
     int counter) {
   HtmlTree tdSummaryType = new HtmlTree(HtmlTag.TD);
   tdSummaryType.addStyle(HtmlStyle.colFirst);
   writer.addSummaryType(this, member, tdSummaryType);
   HtmlTree tdSummary = new HtmlTree(HtmlTag.TD);
   setSummaryColumnStyle(tdSummary);
   addSummaryLink(classDoc, member, tdSummary);
   writer.addSummaryLinkComment(this, member, firstSentenceTags, tdSummary);
   HtmlTree tr = HtmlTree.TR(tdSummaryType);
   tr.addContent(tdSummary);
   if (member instanceof MethodDoc && !member.isAnnotationTypeElement()) {
     int methodType =
         (member.isStatic()) ? MethodTypes.STATIC.value() : MethodTypes.INSTANCE.value();
     if (member.containingClass().isInterface()) {
       methodType =
           (((MethodDoc) member).isAbstract())
               ? methodType | MethodTypes.ABSTRACT.value()
               : methodType | MethodTypes.DEFAULT.value();
     } else {
       methodType =
           (((MethodDoc) member).isAbstract())
               ? methodType | MethodTypes.ABSTRACT.value()
               : methodType | MethodTypes.CONCRETE.value();
     }
     if (utils.isDeprecated(member) || utils.isDeprecated(classdoc)) {
       methodType = methodType | MethodTypes.DEPRECATED.value();
     }
     methodTypesOr = methodTypesOr | methodType;
     String tableId = "i" + counter;
     typeMap.put(tableId, methodType);
     tr.addAttr(HtmlAttr.ID, tableId);
   }
   if (counter % 2 == 0) tr.addStyle(HtmlStyle.altColor);
   else tr.addStyle(HtmlStyle.rowColor);
   tableContents.add(tr);
 }
Exemple #10
0
 /** Build the deprecation information. */
 public void buildDeprecationInfo() {
   writer.writeDeprecated((FieldDoc) enumConstants.get(currentEnumConstantsIndex));
 }
Exemple #11
0
 /** Build the signature. */
 public void buildSignature() {
   writer.writeSignature((FieldDoc) enumConstants.get(currentEnumConstantsIndex));
 }
Exemple #12
0
 /** Build the header for the individual enum constants. */
 public void buildEnumConstantHeader() {
   writer.writeEnumConstantHeader(
       (FieldDoc) enumConstants.get(currentEnumConstantsIndex), currentEnumConstantsIndex == 0);
 }
Exemple #13
0
 /** summaryOrder.size() */
 public boolean hasMembersToDocument() {
   return enumConstants.size() > 0;
 }
 /**
  * Add the navigation detail link.
  *
  * @param members the members to be linked
  * @param liNav the content tree to which the navigation detail link will be added
  */
 protected void addNavDetailLink(List<?> members, Content liNav) {
   addNavDetailLink(members.size() > 0 ? true : false, liNav);
 }
 /** {@inheritDoc} */
 public boolean hasMembersToDocument() {
   return methods.size() > 0;
 }
 /**
  * Build the signature.
  *
  * @param node the XML element that specifies which components to document
  * @param methodDocTree the content tree to which the documentation will be added
  */
 public void buildSignature(XMLNode node, Content methodDocTree) {
   methodDocTree.addContent(writer.getSignature((MethodDoc) methods.get(currentMethodIndex)));
 }
Exemple #17
0
 /** Build the header for the individual field. */
 public void buildFieldHeader() {
   writer.writeFieldHeader((FieldDoc) fields.get(currentFieldIndex), currentFieldIndex == 0);
 }
 /**
  * Build the deprecation information.
  *
  * @param node the XML element that specifies which components to document
  * @param fieldDocTree the content tree to which the documentation will be added
  */
 public void buildDeprecationInfo(XMLNode node, Content fieldDocTree) {
   writer.addDeprecated((FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
 }
Exemple #19
0
 /** summaryOrder.size() */
 public boolean hasMembersToDocument() {
   return fields.size() > 0;
 }
 /**
  * Build the comments for the field. Do nothing if {@link Configuration#nocomment} is set to true.
  *
  * @param node the XML element that specifies which components to document
  * @param fieldDocTree the content tree to which the documentation will be added
  */
 public void buildFieldComments(XMLNode node, Content fieldDocTree) {
   if (!configuration.nocomment) {
     writer.addComments((FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
   }
 }
Exemple #21
0
 /**
  * Build the comments for the enum constant. Do nothing if {@link Configuration#nocomment} is set
  * to true.
  */
 public void buildEnumConstantComments() {
   if (!configuration.nocomment) {
     writer.writeComments((FieldDoc) enumConstants.get(currentEnumConstantsIndex));
   }
 }
 /**
  * Build the signature.
  *
  * @param node the XML element that specifies which components to document
  * @param fieldDocTree the content tree to which the documentation will be added
  */
 public void buildSignature(XMLNode node, Content fieldDocTree) {
   fieldDocTree.addContent(writer.getSignature((FieldDoc) fields.get(currentFieldIndex)));
 }
Exemple #23
0
 /** Build the tag information. */
 public void buildTagInfo() {
   writer.writeTags((FieldDoc) enumConstants.get(currentEnumConstantsIndex));
 }
Exemple #24
0
 /** Build the tag information. */
 public void buildTagInfo() {
   writer.writeTags((FieldDoc) fields.get(currentFieldIndex));
 }
Exemple #25
0
 /** Build the signature. */
 public void buildSignature() {
   writer.writeSignature((FieldDoc) fields.get(currentFieldIndex));
 }
 /**
  * Build the tag information.
  *
  * @param node the XML element that specifies which components to document
  * @param fieldDocTree the content tree to which the documentation will be added
  */
 public void buildTagInfo(XMLNode node, Content fieldDocTree) {
   writer.addTags((FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
 }
 /**
  * Build the deprecation information.
  *
  * @param node the XML element that specifies which components to document
  * @param methodDocTree the content tree to which the documentation will be added
  */
 public void buildDeprecationInfo(XMLNode node, Content methodDocTree) {
   writer.addDeprecated((MethodDoc) methods.get(currentMethodIndex), methodDocTree);
 }
Exemple #28
0
 /** Build the deprecation information. */
 public void buildDeprecationInfo() {
   writer.writeDeprecated((FieldDoc) fields.get(currentFieldIndex));
 }
 /**
  * Build the tag information.
  *
  * @param node the XML element that specifies which components to document
  * @param methodDocTree the content tree to which the documentation will be added
  */
 public void buildTagInfo(XMLNode node, Content methodDocTree) {
   writer.addTags((MethodDoc) methods.get(currentMethodIndex), methodDocTree);
 }
Exemple #30
0
 /**
  * Build the comments for the field. Do nothing if {@link Configuration#nocomment} is set to true.
  */
 public void buildFieldComments() {
   if (!configuration.nocomment) {
     writer.writeComments((FieldDoc) fields.get(currentFieldIndex));
   }
 }