< prev index next >

src/java.compiler/share/classes/javax/lang/model/util/SimpleTypeVisitor6.java

Print this page




  96      */
  97     @Deprecated(since="9")
  98     protected SimpleTypeVisitor6(){
  99         DEFAULT_VALUE = null;
 100     }
 101 
 102     /**
 103      * Constructor for concrete subclasses; uses the argument for the
 104      * default value.
 105      *
 106      * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
 107      * @deprecated Release 6 is obsolete; update to a visitor for a newer
 108      * release level.
 109      */
 110     @Deprecated(since="9")
 111     protected SimpleTypeVisitor6(R defaultValue){
 112         DEFAULT_VALUE = defaultValue;
 113     }
 114 
 115     /**
 116      * The default action for visit methods.  The implementation in
 117      * this class just returns {@link #DEFAULT_VALUE}; subclasses will
 118      * commonly override this method.

 119      *
 120      * @param e the type to process
 121      * @param p a visitor-specified parameter
 122      * @return {@code DEFAULT_VALUE} unless overridden
 123      */
 124     protected R defaultAction(TypeMirror e, P p) {
 125         return DEFAULT_VALUE;
 126     }
 127 
 128     /**
 129      * {@inheritDoc} This implementation calls {@code defaultAction}.


 130      *
 131      * @param t {@inheritDoc}
 132      * @param p {@inheritDoc}
 133      * @return  the result of {@code defaultAction}
 134      */
 135     public R visitPrimitive(PrimitiveType t, P p) {
 136         return defaultAction(t, p);
 137     }
 138 
 139     /**
 140      * {@inheritDoc} This implementation calls {@code defaultAction}.
 141      *


 142      * @param t {@inheritDoc}
 143      * @param p {@inheritDoc}
 144      * @return  the result of {@code defaultAction}
 145      */
 146     public R visitNull(NullType t, P p){
 147         return defaultAction(t, p);
 148     }
 149 
 150     /**
 151      * {@inheritDoc} This implementation calls {@code defaultAction}.


 152      *
 153      * @param t {@inheritDoc}
 154      * @param p {@inheritDoc}
 155      * @return  the result of {@code defaultAction}
 156      */
 157     public R visitArray(ArrayType t, P p){
 158         return defaultAction(t, p);
 159     }
 160 
 161     /**
 162      * {@inheritDoc} This implementation calls {@code defaultAction}.


 163      *
 164      * @param t {@inheritDoc}
 165      * @param p {@inheritDoc}
 166      * @return  the result of {@code defaultAction}
 167      */
 168     public R visitDeclared(DeclaredType t, P p){
 169         return defaultAction(t, p);
 170     }
 171 
 172     /**
 173      * {@inheritDoc} This implementation calls {@code defaultAction}.


 174      *
 175      * @param t {@inheritDoc}
 176      * @param p {@inheritDoc}
 177      * @return  the result of {@code defaultAction}
 178      */
 179     public R visitError(ErrorType t, P p){
 180         return defaultAction(t, p);
 181     }
 182 
 183     /**
 184      * {@inheritDoc} This implementation calls {@code defaultAction}.


 185      *
 186      * @param t {@inheritDoc}
 187      * @param p {@inheritDoc}
 188      * @return  the result of {@code defaultAction}
 189      */
 190     public R visitTypeVariable(TypeVariable t, P p){
 191         return defaultAction(t, p);
 192     }
 193 
 194     /**
 195      * {@inheritDoc} This implementation calls {@code defaultAction}.


 196      *
 197      * @param t {@inheritDoc}
 198      * @param p {@inheritDoc}
 199      * @return  the result of {@code defaultAction}
 200      */
 201     public R visitWildcard(WildcardType t, P p){
 202         return defaultAction(t, p);
 203     }
 204 
 205     /**
 206      * {@inheritDoc} This implementation calls {@code defaultAction}.


 207      *
 208      * @param t {@inheritDoc}
 209      * @param p {@inheritDoc}
 210      * @return  the result of {@code defaultAction}
 211      */
 212     public R visitExecutable(ExecutableType t, P p) {
 213         return defaultAction(t, p);
 214     }
 215 
 216     /**
 217      * {@inheritDoc} This implementation calls {@code defaultAction}.


 218      *
 219      * @param t {@inheritDoc}
 220      * @param p {@inheritDoc}
 221      * @return  the result of {@code defaultAction}
 222      */
 223     public R visitNoType(NoType t, P p){
 224         return defaultAction(t, p);
 225     }
 226 }


  96      */
  97     @Deprecated(since="9")
  98     protected SimpleTypeVisitor6(){
  99         DEFAULT_VALUE = null;
 100     }
 101 
 102     /**
 103      * Constructor for concrete subclasses; uses the argument for the
 104      * default value.
 105      *
 106      * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
 107      * @deprecated Release 6 is obsolete; update to a visitor for a newer
 108      * release level.
 109      */
 110     @Deprecated(since="9")
 111     protected SimpleTypeVisitor6(R defaultValue){
 112         DEFAULT_VALUE = defaultValue;
 113     }
 114 
 115     /**
 116      * The default action for visit methods.
 117      *
 118      * @implSpec The implementation in this class just returns {@link
 119      * #DEFAULT_VALUE}; subclasses will commonly override this method.
 120      *
 121      * @param e the type to process
 122      * @param p a visitor-specified parameter
 123      * @return {@code DEFAULT_VALUE} unless overridden
 124      */
 125     protected R defaultAction(TypeMirror e, P p) {
 126         return DEFAULT_VALUE;
 127     }
 128 
 129     /**
 130      * {@inheritDoc}
 131      *
 132      * @implSpec This implementation calls {@code defaultAction}.
 133      *
 134      * @param t {@inheritDoc}
 135      * @param p {@inheritDoc}
 136      * @return  the result of {@code defaultAction}
 137      */
 138     public R visitPrimitive(PrimitiveType t, P p) {
 139         return defaultAction(t, p);
 140     }
 141 
 142     /**
 143      * {@inheritDoc} This implementation calls {@code defaultAction}.
 144      *
 145      * @implSpec This implementation calls {@code defaultAction}.
 146      *
 147      * @param t {@inheritDoc}
 148      * @param p {@inheritDoc}
 149      * @return  the result of {@code defaultAction}
 150      */
 151     public R visitNull(NullType t, P p){
 152         return defaultAction(t, p);
 153     }
 154 
 155     /**
 156      * {@inheritDoc}
 157      *
 158      * @implSpec This implementation calls {@code defaultAction}.
 159      *
 160      * @param t {@inheritDoc}
 161      * @param p {@inheritDoc}
 162      * @return  the result of {@code defaultAction}
 163      */
 164     public R visitArray(ArrayType t, P p){
 165         return defaultAction(t, p);
 166     }
 167 
 168     /**
 169      * {@inheritDoc}
 170      *
 171      * @implSpec This implementation calls {@code defaultAction}.
 172      *
 173      * @param t {@inheritDoc}
 174      * @param p {@inheritDoc}
 175      * @return  the result of {@code defaultAction}
 176      */
 177     public R visitDeclared(DeclaredType t, P p){
 178         return defaultAction(t, p);
 179     }
 180 
 181     /**
 182      * {@inheritDoc}
 183      *
 184      * @implSpec This implementation calls {@code defaultAction}.
 185      *
 186      * @param t {@inheritDoc}
 187      * @param p {@inheritDoc}
 188      * @return  the result of {@code defaultAction}
 189      */
 190     public R visitError(ErrorType t, P p){
 191         return defaultAction(t, p);
 192     }
 193 
 194     /**
 195      * {@inheritDoc}
 196      *
 197      * @implSpec This implementation calls {@code defaultAction}.
 198      *
 199      * @param t {@inheritDoc}
 200      * @param p {@inheritDoc}
 201      * @return  the result of {@code defaultAction}
 202      */
 203     public R visitTypeVariable(TypeVariable t, P p){
 204         return defaultAction(t, p);
 205     }
 206 
 207     /**
 208      * {@inheritDoc}
 209      *
 210      * @implSpec This implementation calls {@code defaultAction}.
 211      *
 212      * @param t {@inheritDoc}
 213      * @param p {@inheritDoc}
 214      * @return  the result of {@code defaultAction}
 215      */
 216     public R visitWildcard(WildcardType t, P p){
 217         return defaultAction(t, p);
 218     }
 219 
 220     /**
 221      * {@inheritDoc}
 222      *
 223      * @implSpec This implementation calls {@code defaultAction}.
 224      *
 225      * @param t {@inheritDoc}
 226      * @param p {@inheritDoc}
 227      * @return  the result of {@code defaultAction}
 228      */
 229     public R visitExecutable(ExecutableType t, P p) {
 230         return defaultAction(t, p);
 231     }
 232 
 233     /**
 234      * {@inheritDoc}
 235      *
 236      * @implSpec This implementation calls {@code defaultAction}.
 237      *
 238      * @param t {@inheritDoc}
 239      * @param p {@inheritDoc}
 240      * @return  the result of {@code defaultAction}
 241      */
 242     public R visitNoType(NoType t, P p){
 243         return defaultAction(t, p);
 244     }
 245 }
< prev index next >