1 /*

     2  * Copyright (c) 2005, 2017, 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.source.util;

    27 

    28 import com.sun.source.doctree.*;

    29 

    30 /**

    31  * A simple visitor for tree nodes.

    32  *

    33  * @param <R> the return type of this visitor's methods.  Use {@link

    34  *            Void} for visitors that do not need to return results.

    35  * @param <P> the type of the additional parameter to this visitor's

    36  *            methods.  Use {@code Void} for visitors that do not need an

    37  *            additional parameter.

    38  *

    39  * @since 1.8

    40  */

    41 public class SimpleDocTreeVisitor<R,P> implements DocTreeVisitor<R, P> {

    42     /**

    43      * The default value, returned by the {@link #defaultAction default action}.

    44      */

    45     protected final R DEFAULT_VALUE;

    46 

    47     /**

    48      * Creates a visitor, with a DEFAULT_VALUE of {@code null}.

    49      */

    50     protected SimpleDocTreeVisitor() {

    51         DEFAULT_VALUE = null;

    52     }

    53 

    54     /**

    55      * Creates a visitor, with a specified DEFAULT_VALUE.

    56      * @param defaultValue the default value to be returned by the default action.

    57      */

    58     protected SimpleDocTreeVisitor(R defaultValue) {

    59         DEFAULT_VALUE = defaultValue;

    60     }

    61 

    62     /**

    63      * The default action, used by all visit methods that are not overridden.

    64      * @param node the node being visited

    65      * @param p the parameter value passed to the visit method

    66      * @return the result value to be returned from the visit method

    67      */

    68     protected R defaultAction(DocTree node, P p) {

    69         return DEFAULT_VALUE;

    70     }

    71 

    72     /**

    73      * Invokes the appropriate visit method specific to the type of the node.

    74      * @param node the node on which to dispatch

    75      * @param p a parameter to be passed to the appropriate visit method

    76      * @return the value returns from the appropriate visit method

    77      */

    78     public final R visit(DocTree node, P p) {

    79         return (node == null) ? null : node.accept(this, p);

    80     }

    81 

    82     /**

    83      * Invokes the appropriate visit method on each of a sequence of nodes.

    84      * @param nodes the nodes on which to dispatch

    85      * @param p a parameter value to be passed to each appropriate visit method

    86      * @return the value return from the last of the visit methods, or null

    87      *      if none were called.

    88      */

    89     public final R visit(Iterable<? extends DocTree> nodes, P p) {

    90         R r = null;

    91         if (nodes != null) {

    92             for (DocTree node : nodes)

    93                 r = visit(node, p);

    94         }

    95         return r;

    96     }

    97 

    98     /**

    99      * {@inheritDoc} This implementation calls {@code defaultAction}.

   100      *

   101      * @param node {@inheritDoc}

   102      * @param p {@inheritDoc}

   103      * @return  the result of {@code defaultAction}

   104      */

   105     @Override

   106     public R visitAttribute(AttributeTree node, P p) {

   107         return defaultAction(node, p);

   108     }

   109 

   110     /**

   111      * {@inheritDoc} This implementation calls {@code defaultAction}.

   112      *

   113      * @param node {@inheritDoc}

   114      * @param p {@inheritDoc}

   115      * @return  the result of {@code defaultAction}

   116      */

   117     @Override

   118     public R visitAuthor(AuthorTree node, P p) {

   119         return defaultAction(node, p);

   120     }

   121 

   122     /**

   123      * {@inheritDoc} This implementation calls {@code defaultAction}.

   124      *

   125      * @param node {@inheritDoc}

   126      * @param p {@inheritDoc}

   127      * @return  the result of {@code defaultAction}

   128      */

   129     @Override

   130     public R visitComment(CommentTree node, P p) {

   131         return defaultAction(node, p);

   132     }

   133 

   134     /**

   135      * {@inheritDoc} This implementation calls {@code defaultAction}.

   136      *

   137      * @param node {@inheritDoc}

   138      * @param p {@inheritDoc}

   139      * @return  the result of {@code defaultAction}

   140      */

   141     @Override

   142     public R visitDeprecated(DeprecatedTree node, P p) {

   143         return defaultAction(node, p);

   144     }

   145 

   146     /**

   147      * {@inheritDoc} This implementation calls {@code defaultAction}.

   148      *

   149      * @param node {@inheritDoc}

   150      * @param p {@inheritDoc}

   151      * @return  the result of {@code defaultAction}

   152      */

   153     @Override

   154     public R visitDocComment(DocCommentTree node, P p) {

   155         return defaultAction(node, p);

   156     }

   157 

   158     /**

   159      * {@inheritDoc} This implementation calls {@code defaultAction}.

   160      *

   161      * @param node {@inheritDoc}

   162      * @param p {@inheritDoc}

   163      * @return  the result of {@code defaultAction}

   164      */

   165     @Override

   166     public R visitDocRoot(DocRootTree node, P p) {

   167         return defaultAction(node, p);

   168     }

   169 

   170     /**

   171      * {@inheritDoc} This implementation calls {@code defaultAction}.

   172      *

   173      * @param node {@inheritDoc}

   174      * @param p {@inheritDoc}

   175      * @return  the result of {@code defaultAction}

   176      */

   177     @Override

   178     public R visitEndElement(EndElementTree node, P p) {

   179         return defaultAction(node, p);

   180     }

   181 

   182     /**

   183      * {@inheritDoc} This implementation calls {@code defaultAction}.

   184      *

   185      * @param node {@inheritDoc}

   186      * @param p {@inheritDoc}

   187      * @return  the result of {@code defaultAction}

   188      */

   189     @Override

   190     public R visitEntity(EntityTree node, P p) {

   191         return defaultAction(node, p);

   192     }

   193 

   194     /**

   195      * {@inheritDoc} This implementation calls {@code defaultAction}.

   196      *

   197      * @param node {@inheritDoc}

   198      * @param p {@inheritDoc}

   199      * @return  the result of {@code defaultAction}

   200      */

   201     @Override

   202     public R visitErroneous(ErroneousTree node, P p) {

   203         return defaultAction(node, p);

   204     }

   205 

   206     /**

   207      * {@inheritDoc} This implementation calls {@code defaultAction}.

   208      *

   209      * @param node {@inheritDoc}

   210      * @param p {@inheritDoc}

   211      * @return the result of {@code defaultAction}

   212      */

   213     @Override

   214     public R visitHidden(HiddenTree node, P p) {

   215         return defaultAction(node, p);

   216     }

   217 

   218     /**

   219      * {@inheritDoc} This implementation calls {@code defaultAction}.

   220      *

   221      * @param node {@inheritDoc}

   222      * @param p {@inheritDoc}

   223      * @return  the result of {@code defaultAction}

   224      */

   225     @Override

   226     public R visitIdentifier(IdentifierTree node, P p) {

   227         return defaultAction(node, p);

   228     }

   229 

   230     /**

   231      * {@inheritDoc} This implementation calls {@code defaultAction}.

   232      *

   233      * @param node {@inheritDoc}

   234      * @param p {@inheritDoc}

   235      * @return  the result of {@code defaultAction}

   236      */

   237     @Override

   238     public R visitIndex(IndexTree node, P p) {

   239         return defaultAction(node, p);

   240     }

   241 

   242     /**

   243      * {@inheritDoc} This implementation calls {@code defaultAction}.

   244      *

   245      * @param node {@inheritDoc}

   246      * @param p {@inheritDoc}

   247      * @return  the result of {@code defaultAction}

   248      */

   249     @Override

   250     public R visitInheritDoc(InheritDocTree node, P p) {

   251         return defaultAction(node, p);

   252     }

   253 

   254     /**

   255      * {@inheritDoc} This implementation calls {@code defaultAction}.

   256      *

   257      * @param node {@inheritDoc}

   258      * @param p {@inheritDoc}

   259      * @return  the result of {@code defaultAction}

   260      */

   261     @Override

   262     public R visitLink(LinkTree node, P p) {

   263         return defaultAction(node, p);

   264     }

   265 

   266     /**

   267      * {@inheritDoc} This implementation calls {@code defaultAction}.

   268      *

   269      * @param node {@inheritDoc}

   270      * @param p {@inheritDoc}

   271      * @return  the result of {@code defaultAction}

   272      */

   273     @Override

   274     public R visitLiteral(LiteralTree node, P p) {

   275         return defaultAction(node, p);

   276     }

   277 

   278     /**

   279      * {@inheritDoc} This implementation calls {@code defaultAction}.

   280      *

   281      * @param node {@inheritDoc}

   282      * @param p {@inheritDoc}

   283      * @return  the result of {@code defaultAction}

   284      */

   285     @Override

   286     public R visitParam(ParamTree node, P p) {

   287         return defaultAction(node, p);

   288     }

   289 

   290     /**

   291      * {@inheritDoc} This implementation calls {@code defaultAction}.

   292      *

   293      * @param node {@inheritDoc}

   294      * @param p {@inheritDoc}

   295      * @return  the result of {@code defaultAction}

   296      */

   297     @Override

   298     public R visitProvides(ProvidesTree node, P p) {

   299         return defaultAction(node, p);

   300     }

   301 

   302     /**

   303      * {@inheritDoc} This implementation calls {@code defaultAction}.

   304      *

   305      * @param node {@inheritDoc}

   306      * @param p {@inheritDoc}

   307      * @return  the result of {@code defaultAction}

   308      */

   309     @Override

   310     public R visitReference(ReferenceTree node, P p) {

   311         return defaultAction(node, p);

   312     }

   313 

   314     /**

   315      * {@inheritDoc} This implementation calls {@code defaultAction}.

   316      *

   317      * @param node {@inheritDoc}

   318      * @param p {@inheritDoc}

   319      * @return  the result of {@code defaultAction}

   320      */

   321     @Override

   322     public R visitReturn(ReturnTree node, P p) {

   323         return defaultAction(node, p);

   324     }

   325 

   326     /**

   327      * {@inheritDoc} This implementation calls {@code defaultAction}.

   328      *

   329      * @param node {@inheritDoc}

   330      * @param p {@inheritDoc}

   331      * @return  the result of {@code defaultAction}

   332      */

   333     @Override

   334     public R visitSee(SeeTree node, P p) {

   335         return defaultAction(node, p);

   336     }

   337 

   338     /**

   339      * {@inheritDoc} This implementation calls {@code defaultAction}.

   340      *

   341      * @param node {@inheritDoc}

   342      * @param p {@inheritDoc}

   343      * @return  the result of {@code defaultAction}

   344      */

   345     @Override

   346     public R visitSerial(SerialTree node, P p) {

   347         return defaultAction(node, p);

   348     }

   349 

   350     /**

   351      * {@inheritDoc} This implementation calls {@code defaultAction}.

   352      *

   353      * @param node {@inheritDoc}

   354      * @param p {@inheritDoc}

   355      * @return  the result of {@code defaultAction}

   356      */

   357     @Override

   358     public R visitSerialData(SerialDataTree node, P p) {

   359         return defaultAction(node, p);

   360     }

   361 

   362     /**

   363      * {@inheritDoc} This implementation calls {@code defaultAction}.

   364      *

   365      * @param node {@inheritDoc}

   366      * @param p {@inheritDoc}

   367      * @return  the result of {@code defaultAction}

   368      */

   369     @Override

   370     public R visitSerialField(SerialFieldTree node, P p) {

   371         return defaultAction(node, p);

   372     }

   373 

   374     /**

   375      * {@inheritDoc} This implementation calls {@code defaultAction}.

   376      *

   377      * @param node {@inheritDoc}

   378      * @param p {@inheritDoc}

   379      * @return  the result of {@code defaultAction}

   380      */

   381     @Override

   382     public R visitSince(SinceTree node, P p) {

   383         return defaultAction(node, p);

   384     }

   385 

   386     /**

   387      * {@inheritDoc} This implementation calls {@code defaultAction}.

   388      *

   389      * @param node {@inheritDoc}

   390      * @param p {@inheritDoc}

   391      * @return  the result of {@code defaultAction}

   392      */

   393     @Override

   394     public R visitStartElement(StartElementTree node, P p) {

   395         return defaultAction(node, p);

   396     }

   397 

   398     /**

   399      * {@inheritDoc} This implementation calls {@code defaultAction}.

   400      *

   401      * @param node {@inheritDoc}

   402      * @param p {@inheritDoc}

   403      * @return  the result of {@code defaultAction}

   404      * @since 10

   405      */

   406     @Override

   407     public R visitSummary(SummaryTree node, P p) {

   408         return defaultAction(node, p);

   409     }

   410 

   411     /**

   412      * {@inheritDoc} This implementation calls {@code defaultAction}.

   413      *

   414      * @param node {@inheritDoc}

   415      * @param p {@inheritDoc}

   416      * @return  the result of {@code defaultAction}

   417      */

   418     @Override

   419     public R visitText(TextTree node, P p) {

   420         return defaultAction(node, p);

   421     }

   422 

   423     /**

   424      * {@inheritDoc} This implementation calls {@code defaultAction}.

   425      *

   426      * @param node {@inheritDoc}

   427      * @param p {@inheritDoc}

   428      * @return  the result of {@code defaultAction}

   429      */

   430     @Override

   431     public R visitThrows(ThrowsTree node, P p) {

   432         return defaultAction(node, p);

   433     }

   434 

   435     /**

   436      * {@inheritDoc} This implementation calls {@code defaultAction}.

   437      *

   438      * @param node {@inheritDoc}

   439      * @param p {@inheritDoc}

   440      * @return  the result of {@code defaultAction}

   441      */

   442     @Override

   443     public R visitUnknownBlockTag(UnknownBlockTagTree node, P p) {

   444         return defaultAction(node, p);

   445     }

   446 

   447     /**

   448      * {@inheritDoc} This implementation calls {@code defaultAction}.

   449      *

   450      * @param node {@inheritDoc}

   451      * @param p {@inheritDoc}

   452      * @return  the result of {@code defaultAction}

   453      */

   454     @Override

   455     public R visitUnknownInlineTag(UnknownInlineTagTree node, P p) {

   456         return defaultAction(node, p);

   457     }

   458 

   459     /**

   460      * {@inheritDoc} This implementation calls {@code defaultAction}.

   461      *

   462      * @param node {@inheritDoc}

   463      * @param p {@inheritDoc}

   464      * @return  the result of {@code defaultAction}

   465      */

   466     @Override

   467     public R visitUses(UsesTree node, P p) {

   468         return defaultAction(node, p);

   469     }

   470 

   471     /**

   472      * {@inheritDoc} This implementation calls {@code defaultAction}.

   473      *

   474      * @param node {@inheritDoc}

   475      * @param p {@inheritDoc}

   476      * @return  the result of {@code defaultAction}

   477      */

   478     @Override

   479     public R visitValue(ValueTree node, P p) {

   480         return defaultAction(node, p);

   481     }

   482 

   483     /**

   484      * {@inheritDoc} This implementation calls {@code defaultAction}.

   485      *

   486      * @param node {@inheritDoc}

   487      * @param p {@inheritDoc}

   488      * @return  the result of {@code defaultAction}

   489      */

   490     @Override

   491     public R visitVersion(VersionTree node, P p) {

   492         return defaultAction(node, p);

   493     }

   494 

   495     /**

   496      * {@inheritDoc} This implementation calls {@code defaultAction}.

   497      *

   498      * @param node {@inheritDoc}

   499      * @param p {@inheritDoc}

   500      * @return  the result of {@code defaultAction}

   501      */

   502     @Override

   503     public R visitOther(DocTree node, P p) {

   504         return defaultAction(node, p);

   505     }

   506 

   507 }