Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2013 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.reflect;
 
 
 import java.util.Set;
 
Based on what a java.lang.reflect.Type is, dispatch it to the corresponding visit* method. By default, no recursion is done for type arguments or type bounds. But subclasses can opt to do recursion by calling visit(java.lang.reflect.Type[]) for any Type while visitation is in progress. For example, this can be used to reject wildcards or type variables contained in a type as in:
   new TypeVisitor() {
     protected void visitParameterizedType(ParameterizedType t) {
       visit(t.getOwnerType());
       visit(t.getActualTypeArguments());
     
     protected void visitGenericArrayType(GenericArrayType t) {
       visit(t.getGenericComponentType());
     }
     protected void visitTypeVariable(TypeVariable<?> t) {
       throw new IllegalArgumentException("Cannot contain type variable.");
     }
     protected void visitWildcardType(WildcardType t) {
       throw new IllegalArgumentException("Cannot contain wildcard type.");
     }
   }.visit(type);}

One Type is visited at most once. The second time the same type is visited, it's ignored by visit(java.lang.reflect.Type[]). This avoids infinite recursion caused by recursive type bounds.

This class is not thread safe.

Author(s):
Ben Yu
 
 abstract class TypeVisitor {
 
   private final Set<Typevisited = Sets.newHashSet();

  
Visits the given types. Null types are ignored. This allows subclasses to call visit(parameterizedType.getOwnerType()) safely without having to check nulls.
 
   public final void visit(Type... types) {
     for (Type type : types) {
       if (type == null || !.add(type)) {
         // null owner type, or already visited;
         continue;
       }
       boolean succeeded = false;
       try {
         if (type instanceof TypeVariable) {
           visitTypeVariable((TypeVariable<?>) type);
         } else if (type instanceof WildcardType) {
           visitWildcardType((WildcardTypetype);
         } else if (type instanceof ParameterizedType) {
           visitParameterizedType((ParameterizedTypetype);
         } else if (type instanceof Class) {
           visitClass((Class<?>) type);
         } else if (type instanceof GenericArrayType) {
           visitGenericArrayType((GenericArrayTypetype);
         } else {
           throw new AssertionError("Unknown type: " + type);
         }
         succeeded = true;
       } finally {
         if (!succeeded) { // When the visitation failed, we don't want to ignore the second.
           .remove(type);
         }
       }
     }
   }
 
   void visitClass(Class<?> t) {}
  void visitTypeVariable(TypeVariable<?> t) {}
New to GrepCode? Check out our FAQ X