Java TypeVisitor類代碼示例

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
	return v.visitNoType(this, p);
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
/**
 * Finds all declared types (classes and interfaces) that are referenced in the given
 * {@code Set<TypeMirror>}. This includes classes and interfaces that appear directly in the set,
 * but also ones that appear in type parameters and the like. For example, if the set contains
 * {@code java.util.List<? extends java.lang.Number>} then both {@code java.util.List} and
 * {@code java.lang.Number} will be in the resulting set.
 */
private static Set<TypeMirror> referencedClassTypes(Types typeUtil, Set<TypeMirror> types) {
  Set<TypeMirror> referenced = new HashSet<TypeMirror>();
  TypeVisitor<Void, Void> typeVisitor = new ReferencedClassTypeVisitor(typeUtil, referenced);
  for (TypeMirror type : types) {
    type.accept(typeVisitor, null);
  }
  return referenced;
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p)
{
	switch(this.getKind())
	{
		case NULL :
			return v.visitNull(this, p);
		default: 
			return v.visitNoType(this, p);
	}
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public Void visitIntersection(IntersectionType t, StringBuilderAndState<TypeMirror> state) {
    Iterator<? extends TypeMirror> it = IgnoreCompletionFailures.in(t::getBounds).iterator();
    if (it.hasNext()) {
        it.next().accept(this, state);
    }

    TypeVisitor<Void, StringBuilderAndState<TypeMirror>> me = this;

    it.forEachRemaining(b -> { state.bld.append(", "); b.accept(me, state); });

    return null;
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
private DeclaredType getMockAnnotationType() {
  return new DeclaredType() {
    @Override
    public String toString() {
      return UsesMocks.class.getName();
    }

    @Override
    public Element asElement() {
      return null;
    }

    @Override
    public TypeMirror getEnclosingType() {
      return null;
    }

    @Override
    public List<? extends TypeMirror> getTypeArguments() {
      return null;
    }

    @Override
    public <R, P> R accept(TypeVisitor<R, P> v, P p) {
      return null;
    }

    @Override
    public TypeKind getKind() {
      return null;
    }
  };
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
private String getMethodDescriptor(ExecutableElement element) {
    final StringBuilder buf = new StringBuilder();
    buf.append(element.getSimpleName()).append('(');
    TypeVisitor<Void, Void> typeWriter = new BinaryTypeWriter(buf);
    for ( VariableElement param : element.getParameters() ) {
        TypeMirror type = processingEnv.getTypeUtils().erasure(param.asType());
        type.accept(typeWriter, null);
    }
    buf.append(')');
    processingEnv.getTypeUtils().erasure(element.getReturnType()).accept(typeWriter, null);
    return buf.toString();
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
  switch (kind) {
    case BOOLEAN:
    case BYTE:
    case SHORT:
    case INT:
    case LONG:
    case CHAR:
    case FLOAT:
    case DOUBLE:
      return v.visitPrimitive((PrimitiveType) this, p);
    case PACKAGE:
    case VOID:
    case NONE:
      return v.visitNoType((NoType) this, p);
    case NULL:
      return v.visitNull((NullType) this, p);
    case ARRAY:
      return v.visitArray((ArrayType) this, p);
    case DECLARED:
      return v.visitDeclared((DeclaredType) this, p);
    case ERROR:
      return v.visitError((ErrorType) this, p);
    case TYPEVAR:
      return v.visitTypeVariable((TypeVariable) this, p);
    case WILDCARD:
      return v.visitWildcard((WildcardType) this, p);
    case EXECUTABLE:
      return v.visitExecutable((ExecutableType) this, p);
    case OTHER:
      return v.visit(this, p);
    case UNION:
      return v.visitUnion((UnionType) this, p);
    case INTERSECTION:
      return v.visitIntersection((IntersectionType) this, p);
    default:
      throw new AssertionError(String.format("Unknown TypeKind: %s", kind));
  }
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
private static TypeMirror noType() {
    return new NoType() {
        @Override
        public <R, P> R accept(TypeVisitor<R, P> v, P p) {
            throw new UnsupportedOperationException();
        }

        @Override
        public TypeKind getKind() {
            throw new UnsupportedOperationException();
        }
    };
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
  return delegate.accept(v, p);
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
    if (isPrimitive())
        return v.visitPrimitive(this, p);
    else
        throw new AssertionError();
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
    throw new IllegalStateException();
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
    return null;
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
public ParameterVisitor( TypeVisitor<Boolean,Void> parameterTypeVisitor )
{
    this.parameterTypeVisitor = parameterTypeVisitor;
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
protected TypeVisitor<Boolean,Void> visitor()
{
    return new RecordFieldTypeVisitor( types, typeMirrorUtils );
}
 

import javax.lang.model.type.TypeVisitor; //導入依賴的package包/類
@Override
protected TypeVisitor<Boolean,Void> visitor()
{
    return new ParameterTypeVisitor( types, typeMirrorUtils );
}