< prev index next >

src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/AbstractExecutableMemberWriter.java

Print this page




  56  *
  57  *  <p><b>This is NOT part of any supported API.
  58  *  If you write code that depends on this, you do so at your own risk.
  59  *  This code and its internal interfaces are subject to change or
  60  *  deletion without notice.</b>
  61  *
  62  * @author Robert Field
  63  * @author Atul M Dambalkar
  64  * @author Bhavesh Patel (Modified)
  65  */
  66 public abstract class AbstractExecutableMemberWriter extends AbstractMemberWriter {
  67 
  68     public AbstractExecutableMemberWriter(SubWriterHolderWriter writer, TypeElement typeElement) {
  69         super(writer, typeElement);
  70     }
  71 
  72     public AbstractExecutableMemberWriter(SubWriterHolderWriter writer) {
  73         super(writer);
  74     }
  75 
  76     /**
  77      * Add the type parameters for the executable member.
  78      *
  79      * @param member the member to write type parameters for.
  80      * @param htmltree the content tree to which the parameters will be added.
  81      */
  82     protected void addTypeParameters(ExecutableElement member, Content htmltree) {
  83         Content typeParameters = getTypeParameters(member);
  84         if (!typeParameters.isEmpty()) {
  85             htmltree.add(typeParameters);
  86             htmltree.add(Entity.NO_BREAK_SPACE);
  87         }
  88     }
  89 
  90     /**
  91      * Get the type parameters for the executable member.
  92      *
  93      * @param member the member for which to get the type parameters.
  94      * @return the type parameters.
  95      */
  96     protected Content getTypeParameters(ExecutableElement member) {
  97         LinkInfoImpl linkInfo = new LinkInfoImpl(configuration, MEMBER_TYPE_PARAMS, member);
  98         return writer.getTypeParameterLinks(linkInfo);
  99     }
 100 
 101     /**
 102      * {@inheritDoc}
 103      */
 104     @Override
 105     protected Content getDeprecatedLink(Element member) {
 106         Content deprecatedLinkContent = new ContentBuilder();
 107         deprecatedLinkContent.add(utils.getFullyQualifiedName(member));
 108         if (!utils.isConstructor(member)) {


 117 
 118         return writer.getDocLink(MEMBER, utils.getEnclosingTypeElement(member), member, deprecatedLinkContent);
 119     }
 120 
 121     /**
 122      * Add the summary link for the member.
 123      *
 124      * @param context the id of the context where the link will be printed
 125      * @param te the type element being linked to
 126      * @param member the member being linked to
 127      * @param tdSummary the content tree to which the link will be added
 128      */
 129     @Override
 130     protected void addSummaryLink(LinkInfoImpl.Kind context, TypeElement te, Element member,
 131             Content tdSummary) {
 132         ExecutableElement ee = (ExecutableElement)member;
 133         Content memberLink = HtmlTree.SPAN(HtmlStyle.memberNameLink,
 134                 writer.getDocLink(context, te, ee,
 135                 name(ee), false));
 136         Content code = HtmlTree.CODE(memberLink);
 137         addParameters(ee, false, code, name(ee).length() - 1);
 138         tdSummary.add(code);
 139     }
 140 
 141     /**
 142      * Add the inherited summary link for the member.
 143      *
 144      * @param te the type element that we should link to
 145      * @param member the member being linked to
 146      * @param linksTree the content tree to which the link will be added
 147      */
 148     @Override
 149     protected void addInheritedSummaryLink(TypeElement te, Element member, Content linksTree) {
 150         linksTree.add(writer.getDocLink(MEMBER, te, member, name(member), false));
 151     }
 152 
 153     /**
 154      * Add the parameter for the executable member.
 155      *
 156      * @param member the member to write parameter for.
 157      * @param param the parameter that needs to be written.
 158      * @param isVarArg true if this is a link to var arg.
 159      * @param tree the content tree to which the parameter information will be added.
 160      */
 161     protected void addParam(ExecutableElement member, VariableElement param,
 162             boolean isVarArg, Content tree) {
 163         Content link = writer.getLink(new LinkInfoImpl(configuration, EXECUTABLE_MEMBER_PARAM,
 164                 param.asType()).varargs(isVarArg));
 165         tree.add(link);
 166         if(name(param).length() > 0) {
 167             tree.add(Entity.NO_BREAK_SPACE);
 168             tree.add(name(param));
 169         }
 170     }
 171 
 172     /**
 173      * Add the receiver annotations information.
 174      *
 175      * @param member the member to write receiver annotations for.
 176      * @param rcvrType the receiver type.
 177      * @param descList list of annotation description.
 178      * @param tree the content tree to which the information will be added.
 179      */
 180     protected void addReceiverAnnotations(ExecutableElement member, TypeMirror rcvrType,
 181             List<? extends AnnotationMirror> annotationMirrors, Content tree) {
 182         writer.addReceiverAnnotationInfo(member, rcvrType, annotationMirrors, tree);
 183         tree.add(Entity.NO_BREAK_SPACE);
 184         tree.add(utils.getTypeName(rcvrType, false));
 185         LinkInfoImpl linkInfo = new LinkInfoImpl(configuration, RECEIVER_TYPE, rcvrType);
 186         tree.add(writer.getTypeParameterLinks(linkInfo));
 187         tree.add(Entity.NO_BREAK_SPACE);
 188         tree.add("this");
 189     }
 190 
 191 
 192     /**
 193      * Add all the parameters for the executable member.
 194      *
 195      * @param member the member to write parameters for.
 196      * @param htmltree the content tree to which the parameters information will be added.
 197      */
 198     protected void addParameters(ExecutableElement member, Content htmltree, int indentSize) {
 199         addParameters(member, true, htmltree, indentSize);








 200     }
 201 
 202     /**
 203      * Add all the parameters for the executable member.
 204      *
 205      * @param member the member to write parameters for.
 206      * @param includeAnnotations true if annotation information needs to be added.
 207      * @param htmltree the content tree to which the parameters information will be added.
 208      */
 209     protected void addParameters(ExecutableElement member,
 210             boolean includeAnnotations, Content htmltree, int indentSize) {
 211         Content paramTree = new ContentBuilder();
 212         String sep = "";
 213         List<? extends VariableElement> parameters = member.getParameters();
 214         CharSequence indent = makeSpace(indentSize + 1);
 215         TypeMirror rcvrType = member.getReceiverType();
 216         if (includeAnnotations && rcvrType != null && utils.isAnnotated(rcvrType)) {
 217             List<? extends AnnotationMirror> annotationMirrors = rcvrType.getAnnotationMirrors();
 218             addReceiverAnnotations(member, rcvrType, annotationMirrors, paramTree);
 219             sep = "," + DocletConstants.NL + indent;
 220         }
 221         int paramstart;
 222         for (paramstart = 0; paramstart < parameters.size(); paramstart++) {
 223             paramTree.add(sep);
 224             VariableElement param = parameters.get(paramstart);
 225 
 226             if (param.getKind() != ElementKind.INSTANCE_INIT) {
 227                 if (includeAnnotations) {
 228                     boolean foundAnnotations =
 229                             writer.addAnnotationInfo(indent.length(),
 230                             member, param, paramTree);
 231                     if (foundAnnotations) {
 232                         paramTree.add(DocletConstants.NL);
 233                         paramTree.add(indent);
 234                     }
 235                 }
 236                 addParam(member, param,
 237                     (paramstart == parameters.size() - 1) && member.isVarArgs(), paramTree);
 238                 break;
 239             }
 240         }
 241 
 242         for (int i = paramstart + 1; i < parameters.size(); i++) {
 243             paramTree.add(",");
 244             paramTree.add(DocletConstants.NL);
 245             paramTree.add(indent);
 246             if (includeAnnotations) {
 247                 boolean foundAnnotations =
 248                         writer.addAnnotationInfo(indent.length(), member, parameters.get(i),
 249                         paramTree);
 250                 if (foundAnnotations) {
 251                     paramTree.add(DocletConstants.NL);
 252                     paramTree.add(indent);
 253                 }
 254             }
 255             addParam(member, parameters.get(i), (i == parameters.size() - 1) && member.isVarArgs(),
 256                     paramTree);
 257         }
 258         if (paramTree.isEmpty()) {
 259             htmltree.add("()");
 260         } else {
 261             htmltree.add(Entity.ZERO_WIDTH_SPACE);
 262             htmltree.add("(");
 263             htmltree.add(paramTree);
 264             paramTree.add(")");
 265         }
 266     }
 267 
 268     /**
 269      * Add exceptions for the executable member.
 270      *
 271      * @param member the member to write exceptions for.
 272      * @param htmltree the content tree to which the exceptions information will be added.
 273      */
 274     protected void addExceptions(ExecutableElement member, Content htmltree, int indentSize) {
 275         List<? extends TypeMirror> exceptions = member.getThrownTypes();

 276         if (!exceptions.isEmpty()) {
 277             CharSequence indent = makeSpace(indentSize + 1 - 7);
 278             htmltree.add(DocletConstants.NL);
 279             htmltree.add(indent);
 280             htmltree.add("throws ");
 281             indent = makeSpace(indentSize + 1);
 282             Content link = writer.getLink(new LinkInfoImpl(configuration, MEMBER, exceptions.get(0)));
 283             htmltree.add(link);
 284             for(int i = 1; i < exceptions.size(); i++) {
 285                 htmltree.add(",");
 286                 htmltree.add(DocletConstants.NL);
 287                 htmltree.add(indent);
 288                 Content exceptionLink = writer.getLink(new LinkInfoImpl(configuration, MEMBER,
 289                         exceptions.get(i)));
 290                 htmltree.add(exceptionLink);
 291             }
 292         }

 293     }
 294 
 295     protected TypeElement implementsMethodInIntfac(ExecutableElement method,
 296                                                 List<TypeElement> intfacs) {
 297         for (TypeElement intf : intfacs) {
 298             List<ExecutableElement> methods = utils.getMethods(intf);
 299             if (!methods.isEmpty()) {
 300                 for (ExecutableElement md : methods) {
 301                     if (name(md).equals(name(method)) &&
 302                         md.toString().equals(method.toString())) {
 303                         return intf;
 304                     }
 305                 }
 306             }
 307         }
 308         return null;
 309     }
 310 
 311     /**
 312      * For backward compatibility, include an anchor using the erasures of the




  56  *
  57  *  <p><b>This is NOT part of any supported API.
  58  *  If you write code that depends on this, you do so at your own risk.
  59  *  This code and its internal interfaces are subject to change or
  60  *  deletion without notice.</b>
  61  *
  62  * @author Robert Field
  63  * @author Atul M Dambalkar
  64  * @author Bhavesh Patel (Modified)
  65  */
  66 public abstract class AbstractExecutableMemberWriter extends AbstractMemberWriter {
  67 
  68     public AbstractExecutableMemberWriter(SubWriterHolderWriter writer, TypeElement typeElement) {
  69         super(writer, typeElement);
  70     }
  71 
  72     public AbstractExecutableMemberWriter(SubWriterHolderWriter writer) {
  73         super(writer);
  74     }
  75 













  76 
  77     /**
  78      * Get the type parameters for the executable member.
  79      *
  80      * @param member the member for which to get the type parameters.
  81      * @return the type parameters.
  82      */
  83     protected Content getTypeParameters(ExecutableElement member) {
  84         LinkInfoImpl linkInfo = new LinkInfoImpl(configuration, MEMBER_TYPE_PARAMS, member);
  85         return writer.getTypeParameterLinks(linkInfo);
  86     }
  87 
  88     /**
  89      * {@inheritDoc}
  90      */
  91     @Override
  92     protected Content getDeprecatedLink(Element member) {
  93         Content deprecatedLinkContent = new ContentBuilder();
  94         deprecatedLinkContent.add(utils.getFullyQualifiedName(member));
  95         if (!utils.isConstructor(member)) {


 104 
 105         return writer.getDocLink(MEMBER, utils.getEnclosingTypeElement(member), member, deprecatedLinkContent);
 106     }
 107 
 108     /**
 109      * Add the summary link for the member.
 110      *
 111      * @param context the id of the context where the link will be printed
 112      * @param te the type element being linked to
 113      * @param member the member being linked to
 114      * @param tdSummary the content tree to which the link will be added
 115      */
 116     @Override
 117     protected void addSummaryLink(LinkInfoImpl.Kind context, TypeElement te, Element member,
 118             Content tdSummary) {
 119         ExecutableElement ee = (ExecutableElement)member;
 120         Content memberLink = HtmlTree.SPAN(HtmlStyle.memberNameLink,
 121                 writer.getDocLink(context, te, ee,
 122                 name(ee), false));
 123         Content code = HtmlTree.CODE(memberLink);
 124         addParameters(ee, code);
 125         tdSummary.add(code);
 126     }
 127 
 128     /**
 129      * Add the inherited summary link for the member.
 130      *
 131      * @param te the type element that we should link to
 132      * @param member the member being linked to
 133      * @param linksTree the content tree to which the link will be added
 134      */
 135     @Override
 136     protected void addInheritedSummaryLink(TypeElement te, Element member, Content linksTree) {
 137         linksTree.add(writer.getDocLink(MEMBER, te, member, name(member), false));
 138     }
 139 
 140     /**
 141      * Add the parameter for the executable member.
 142      *
 143      * @param member the member to write parameter for.
 144      * @param param the parameter that needs to be written.
 145      * @param isVarArg true if this is a link to var arg.
 146      * @param tree the content tree to which the parameter information will be added.
 147      */
 148     protected void addParam(ExecutableElement member, VariableElement param,
 149             boolean isVarArg, Content tree) {
 150         Content link = writer.getLink(new LinkInfoImpl(configuration, EXECUTABLE_MEMBER_PARAM,
 151                 param.asType()).varargs(isVarArg));
 152         tree.add(link);
 153         if(name(param).length() > 0) {
 154             tree.add(Entity.NO_BREAK_SPACE);
 155             tree.add(name(param));
 156         }
 157     }
 158 
 159     /**
 160      * Add the receiver annotations information.
 161      *
 162      * @param member the member to write receiver annotations for.
 163      * @param rcvrType the receiver type.
 164      * @param annotationMirrors list of annotation descriptions.
 165      * @param tree the content tree to which the information will be added.
 166      */
 167     protected void addReceiverAnnotations(ExecutableElement member, TypeMirror rcvrType,
 168             List<? extends AnnotationMirror> annotationMirrors, Content tree) {
 169         writer.addReceiverAnnotationInfo(member, rcvrType, annotationMirrors, tree);
 170         tree.add(Entity.NO_BREAK_SPACE);
 171         tree.add(utils.getTypeName(rcvrType, false));
 172         LinkInfoImpl linkInfo = new LinkInfoImpl(configuration, RECEIVER_TYPE, rcvrType);
 173         tree.add(writer.getTypeParameterLinks(linkInfo));
 174         tree.add(Entity.NO_BREAK_SPACE);
 175         tree.add("this");
 176     }
 177 
 178 
 179     /**
 180      * Add all the parameters for the executable member.
 181      *
 182      * @param member the member to write parameters for.
 183      * @param htmltree the content tree to which the parameters information will be added.
 184      */
 185     protected void addParameters(ExecutableElement member, Content htmltree) {
 186         Content paramTree = getParameters(member, false);
 187         if (paramTree.isEmpty()) {
 188             htmltree.add("()");
 189         } else {
 190             htmltree.add(Entity.ZERO_WIDTH_SPACE);
 191             htmltree.add("(");
 192             htmltree.add(paramTree);
 193             paramTree.add(")");
 194         }
 195     }
 196 
 197     /**
 198      * Add all the parameters for the executable member.
 199      *
 200      * @param member the member to write parameters for.
 201      * @param includeAnnotations true if annotation information needs to be added.
 202      * @return the content tree containing the parameter information
 203      */
 204     protected Content getParameters(ExecutableElement member, boolean includeAnnotations) {

 205         Content paramTree = new ContentBuilder();
 206         String sep = "";
 207         List<? extends VariableElement> parameters = member.getParameters();

 208         TypeMirror rcvrType = member.getReceiverType();
 209         if (includeAnnotations && rcvrType != null && utils.isAnnotated(rcvrType)) {
 210             List<? extends AnnotationMirror> annotationMirrors = rcvrType.getAnnotationMirrors();
 211             addReceiverAnnotations(member, rcvrType, annotationMirrors, paramTree);
 212             sep = "," + DocletConstants.NL;
 213         }
 214         int paramstart;
 215         for (paramstart = 0; paramstart < parameters.size(); paramstart++) {
 216             paramTree.add(sep);
 217             VariableElement param = parameters.get(paramstart);
 218 
 219             if (param.getKind() != ElementKind.INSTANCE_INIT) {
 220                 if (includeAnnotations) {
 221                     boolean foundAnnotations =
 222                             writer.addAnnotationInfo(param, paramTree);

 223                     if (foundAnnotations) {
 224                         paramTree.add(DocletConstants.NL);

 225                     }
 226                 }
 227                 addParam(member, param,
 228                     (paramstart == parameters.size() - 1) && member.isVarArgs(), paramTree);
 229                 break;
 230             }
 231         }
 232 
 233         for (int i = paramstart + 1; i < parameters.size(); i++) {
 234             paramTree.add(",");
 235             paramTree.add(DocletConstants.NL);

 236             if (includeAnnotations) {
 237                 boolean foundAnnotations =
 238                         writer.addAnnotationInfo(parameters.get(i),
 239                         paramTree);
 240                 if (foundAnnotations) {
 241                     paramTree.add(DocletConstants.NL);

 242                 }
 243             }
 244             addParam(member, parameters.get(i), (i == parameters.size() - 1) && member.isVarArgs(),
 245                     paramTree);
 246         }
 247 
 248         return paramTree;






 249     }
 250 
 251     /**
 252      * Get a content tree containing the exception information for the executable member.
 253      *
 254      * @param member the member to write exceptions for.
 255      * @return the content tree containing the exceptions information.
 256      */
 257     protected Content getExceptions(ExecutableElement member) {
 258         List<? extends TypeMirror> exceptions = member.getThrownTypes();
 259         Content htmltree = new ContentBuilder();
 260         if (!exceptions.isEmpty()) {





 261             Content link = writer.getLink(new LinkInfoImpl(configuration, MEMBER, exceptions.get(0)));
 262             htmltree.add(link);
 263             for(int i = 1; i < exceptions.size(); i++) {
 264                 htmltree.add(",");
 265                 htmltree.add(DocletConstants.NL);

 266                 Content exceptionLink = writer.getLink(new LinkInfoImpl(configuration, MEMBER,
 267                         exceptions.get(i)));
 268                 htmltree.add(exceptionLink);
 269             }
 270         }
 271         return htmltree;
 272     }
 273 
 274     protected TypeElement implementsMethodInIntfac(ExecutableElement method,
 275                                                 List<TypeElement> intfacs) {
 276         for (TypeElement intf : intfacs) {
 277             List<ExecutableElement> methods = utils.getMethods(intf);
 278             if (!methods.isEmpty()) {
 279                 for (ExecutableElement md : methods) {
 280                     if (name(md).equals(name(method)) &&
 281                         md.toString().equals(method.toString())) {
 282                         return intf;
 283                     }
 284                 }
 285             }
 286         }
 287         return null;
 288     }
 289 
 290     /**
 291      * For backward compatibility, include an anchor using the erasures of the


< prev index next >