< prev index next >

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

Print this page




  23  * questions.
  24  */
  25 
  26 package jdk.javadoc.internal.doclets.formats.html;
  27 
  28 import java.util.ArrayList;
  29 import java.util.List;
  30 
  31 import javax.lang.model.element.AnnotationMirror;
  32 import javax.lang.model.element.Element;
  33 import javax.lang.model.element.TypeElement;
  34 import javax.lang.model.type.DeclaredType;
  35 import javax.lang.model.type.TypeMirror;
  36 
  37 import jdk.javadoc.internal.doclets.formats.html.markup.ContentBuilder;
  38 import jdk.javadoc.internal.doclets.toolkit.BaseConfiguration;
  39 import jdk.javadoc.internal.doclets.toolkit.Content;
  40 import jdk.javadoc.internal.doclets.toolkit.Resources;
  41 import jdk.javadoc.internal.doclets.toolkit.util.DocPath;
  42 import jdk.javadoc.internal.doclets.toolkit.util.DocPaths;

  43 import jdk.javadoc.internal.doclets.toolkit.util.links.LinkFactory;
  44 import jdk.javadoc.internal.doclets.toolkit.util.links.LinkInfo;
  45 
  46 /**
  47  * A factory that returns a link given the information about it.
  48  *
  49  *  <p><b>This is NOT part of any supported API.
  50  *  If you write code that depends on this, you do so at your own risk.
  51  *  This code and its internal interfaces are subject to change or
  52  *  deletion without notice.</b>
  53  *
  54  * @author Jamie Ho
  55  */
  56 public class LinkFactoryImpl extends LinkFactory {
  57 
  58     private final HtmlDocletWriter m_writer;
  59     private final DocPaths docPaths;
  60 
  61     public LinkFactoryImpl(HtmlDocletWriter writer) {
  62         super(writer.configuration.utils);


 116             if (crossLink != null) {
 117                 link.add(crossLink);
 118                 if (noLabel && !classLinkInfo.excludeTypeParameterLinks) {
 119                     link.add(getTypeParameterLinks(linkInfo));
 120                 }
 121                 return link;
 122             }
 123         }
 124         // Can't link so just write label.
 125         link.add(label);
 126         if (noLabel && !classLinkInfo.excludeTypeParameterLinks) {
 127             link.add(getTypeParameterLinks(linkInfo));
 128         }
 129         return link;
 130     }
 131 
 132     /**
 133      * {@inheritDoc}
 134      */
 135     @Override
 136     protected Content getTypeParameterLinks(LinkInfo linkInfo, boolean isClassLabel){
 137         Content links = newContent();
 138         List<TypeMirror> vars = new ArrayList<>();
 139         TypeMirror ctype = linkInfo.type != null
 140                 ? utils.getComponentType(linkInfo.type)
 141                 : null;
 142         if (linkInfo.executableElement != null) {
 143             linkInfo.executableElement.getTypeParameters().stream().forEach((t) -> {
 144                 vars.add(t.asType());
 145             });
 146         } else if (linkInfo.type != null && utils.isDeclaredType(linkInfo.type)) {
 147             ((DeclaredType)linkInfo.type).getTypeArguments().stream().forEach(vars::add);
 148         } else if (ctype != null && utils.isDeclaredType(ctype)) {
 149             ((DeclaredType)ctype).getTypeArguments().stream().forEach(vars::add);
 150         } else if (linkInfo.typeElement != null) {
 151             linkInfo.typeElement.getTypeParameters().stream().forEach((t) -> {
 152                 vars.add(t.asType());
 153             });
 154         } else {
 155             // Nothing to document.
 156             return links;
 157         }
 158         if (((linkInfo.includeTypeInClassLinkLabel && isClassLabel)
 159                 || (linkInfo.includeTypeAsSepLink && !isClassLabel)) && !vars.isEmpty()) {
 160             links.add("<");

 161             boolean many = false;
 162             for (TypeMirror t : vars) {
 163                 if (many) {
 164                     links.add(",");
 165                     links.add(Contents.ZERO_WIDTH_SPACE);




 166                 }
 167                 links.add(getTypeParameterLink(linkInfo, t));
 168                 many = true;
 169             }
 170             links.add(">");
 171         }
 172         return links;
 173     }
 174 
 175     /**
 176      * Returns a link to the given type parameter.
 177      *
 178      * @param linkInfo     the information about the link to construct
 179      * @param typeParam the type parameter to link to
 180      * @return the link
 181      */
 182     protected Content getTypeParameterLink(LinkInfo linkInfo, TypeMirror typeParam) {
 183         LinkInfoImpl typeLinkInfo = new LinkInfoImpl(m_writer.configuration,
 184                 ((LinkInfoImpl) linkInfo).getContext(), typeParam);
 185         typeLinkInfo.excludeTypeBounds = linkInfo.excludeTypeBounds;




  23  * questions.
  24  */
  25 
  26 package jdk.javadoc.internal.doclets.formats.html;
  27 
  28 import java.util.ArrayList;
  29 import java.util.List;
  30 
  31 import javax.lang.model.element.AnnotationMirror;
  32 import javax.lang.model.element.Element;
  33 import javax.lang.model.element.TypeElement;
  34 import javax.lang.model.type.DeclaredType;
  35 import javax.lang.model.type.TypeMirror;
  36 
  37 import jdk.javadoc.internal.doclets.formats.html.markup.ContentBuilder;
  38 import jdk.javadoc.internal.doclets.toolkit.BaseConfiguration;
  39 import jdk.javadoc.internal.doclets.toolkit.Content;
  40 import jdk.javadoc.internal.doclets.toolkit.Resources;
  41 import jdk.javadoc.internal.doclets.toolkit.util.DocPath;
  42 import jdk.javadoc.internal.doclets.toolkit.util.DocPaths;
  43 import jdk.javadoc.internal.doclets.toolkit.util.DocletConstants;
  44 import jdk.javadoc.internal.doclets.toolkit.util.links.LinkFactory;
  45 import jdk.javadoc.internal.doclets.toolkit.util.links.LinkInfo;
  46 
  47 /**
  48  * A factory that returns a link given the information about it.
  49  *
  50  *  <p><b>This is NOT part of any supported API.
  51  *  If you write code that depends on this, you do so at your own risk.
  52  *  This code and its internal interfaces are subject to change or
  53  *  deletion without notice.</b>
  54  *
  55  * @author Jamie Ho
  56  */
  57 public class LinkFactoryImpl extends LinkFactory {
  58 
  59     private final HtmlDocletWriter m_writer;
  60     private final DocPaths docPaths;
  61 
  62     public LinkFactoryImpl(HtmlDocletWriter writer) {
  63         super(writer.configuration.utils);


 117             if (crossLink != null) {
 118                 link.add(crossLink);
 119                 if (noLabel && !classLinkInfo.excludeTypeParameterLinks) {
 120                     link.add(getTypeParameterLinks(linkInfo));
 121                 }
 122                 return link;
 123             }
 124         }
 125         // Can't link so just write label.
 126         link.add(label);
 127         if (noLabel && !classLinkInfo.excludeTypeParameterLinks) {
 128             link.add(getTypeParameterLinks(linkInfo));
 129         }
 130         return link;
 131     }
 132 
 133     /**
 134      * {@inheritDoc}
 135      */
 136     @Override
 137     protected Content getTypeParameterLinks(LinkInfo linkInfo, boolean isClassLabel) {
 138         Content links = newContent();
 139         List<TypeMirror> vars = new ArrayList<>();
 140         TypeMirror ctype = linkInfo.type != null
 141                 ? utils.getComponentType(linkInfo.type)
 142                 : null;
 143         if (linkInfo.executableElement != null) {
 144             linkInfo.executableElement.getTypeParameters().stream().forEach((t) -> {
 145                 vars.add(t.asType());
 146             });
 147         } else if (linkInfo.type != null && utils.isDeclaredType(linkInfo.type)) {
 148             ((DeclaredType)linkInfo.type).getTypeArguments().stream().forEach(vars::add);
 149         } else if (ctype != null && utils.isDeclaredType(ctype)) {
 150             ((DeclaredType)ctype).getTypeArguments().stream().forEach(vars::add);
 151         } else if (linkInfo.typeElement != null) {
 152             linkInfo.typeElement.getTypeParameters().stream().forEach((t) -> {
 153                 vars.add(t.asType());
 154             });
 155         } else {
 156             // Nothing to document.
 157             return links;
 158         }
 159         if (((linkInfo.includeTypeInClassLinkLabel && isClassLabel)
 160                 || (linkInfo.includeTypeAsSepLink && !isClassLabel)) && !vars.isEmpty()) {
 161             links.add("<");
 162             int lineStart = 0;
 163             boolean many = false;
 164             for (TypeMirror t : vars) {
 165                 if (many) {
 166                     links.add(",");
 167                     links.add(Contents.ZERO_WIDTH_SPACE);
 168                     if (links.charCount() - lineStart > DocletConstants.PREFORMATTED_LINE_LENGTH) {
 169                         lineStart = links.charCount();
 170                         links.add(DocletConstants.NL + "        ");
 171                     }
 172                 }
 173                 links.add(getTypeParameterLink(linkInfo, t));
 174                 many = true;
 175             }
 176             links.add(">");
 177         }
 178         return links;
 179     }
 180 
 181     /**
 182      * Returns a link to the given type parameter.
 183      *
 184      * @param linkInfo     the information about the link to construct
 185      * @param typeParam the type parameter to link to
 186      * @return the link
 187      */
 188     protected Content getTypeParameterLink(LinkInfo linkInfo, TypeMirror typeParam) {
 189         LinkInfoImpl typeLinkInfo = new LinkInfoImpl(m_writer.configuration,
 190                 ((LinkInfoImpl) linkInfo).getContext(), typeParam);
 191         typeLinkInfo.excludeTypeBounds = linkInfo.excludeTypeBounds;


< prev index next >