Java Reifier.getResult方法代码示例

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type[] getExceptionTypes(){
    if (exceptionTypes == null) { // lazily initialize exception types
        // first, extract exception type subtree(s) from AST
        FieldTypeSignature[] ets = getTree().getExceptionTypes();
        // create array to store reified subtree(s)
        Type[] es = new Type[ets.length];
        // reify all subtrees
        for (int i = 0; i < ets.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ets[i].accept(r); // reify subtree
            // extract result from visitor and store it
            es[i] = r.getResult();
        }
        exceptionTypes = es; // cache overall result
    }
    return exceptionTypes.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type[] getSuperInterfaces(){
    if (superInterfaces == null) { // lazily initialize super interfaces
        // first, extract super interface subtree(s) from AST
        TypeTree[] ts  = getTree().getSuperInterfaces();
        // create array to store reified subtree(s)
        Type[] sis = new Type[ts.length];
        // reify all subtrees
        for (int i = 0; i < ts.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ts[i].accept(r);// reify subtree
            // extract result from visitor and store it
            sis[i] = r.getResult();
        }
        superInterfaces = sis; // cache overall result
    }
    return superInterfaces.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type[] getParameterTypes(){
    if (paramTypes == null) { // lazily initialize parameter types
        // first, extract parameter type subtree(s) from AST
        TypeSignature[] pts = getTree().getParameterTypes();
        // create array to store reified subtree(s)
        Type[] ps = new Type[pts.length];
        // reify all subtrees
        for (int i = 0; i < pts.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            pts[i].accept(r); // reify subtree
            // extract result from visitor and store it
            ps[i] = r.getResult();
        }
        paramTypes = ps; // cache overall result
    }
    return paramTypes.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
/**
 * Return the formal type parameters of this generic declaration.
 * @return the formal type parameters of this generic declaration
 */
public TypeVariable<?>[] getTypeParameters() {
    TypeVariable<?>[] typeParams = this.typeParams;
    if (typeParams == null) { // lazily initialize type parameters
        // first, extract type parameter subtree(s) from AST
        FormalTypeParameter[] ftps = getTree().getFormalTypeParameters();
        // create array to store reified subtree(s)
        typeParams = new TypeVariable<?>[ftps.length];
        // reify all subtrees
        for (int i = 0; i < ftps.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ftps[i].accept(r); // reify subtree
            // extract result from visitor and store it
            typeParams[i] = (TypeVariable<?>) r.getResult();
        }
        this.typeParams = typeParams; // cache overall result
    }
    return typeParams.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type[] getSuperInterfaces(){
    Type[] superInterfaces = this.superInterfaces;
    if (superInterfaces == null) { // lazily initialize super interfaces
        // first, extract super interface subtree(s) from AST
        TypeTree[] ts  = getTree().getSuperInterfaces();
        // create array to store reified subtree(s)
        Type[] sis = new Type[ts.length];
        // reify all subtrees
        for (int i = 0; i < ts.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ts[i].accept(r);// reify subtree
            // extract result from visitor and store it
            sis[i] = r.getResult();
        }
        superInterfaces = sis; // cache overall result
        this.superInterfaces = superInterfaces;
    }
    return superInterfaces.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type[] getSuperInterfaces() {
    Type[] superInterfaces = this.superInterfaces;
    if (superInterfaces == null) { // lazily initialize super interfaces
        // first, extract super interface subtree(s) from AST
        TypeTree[] ts  = getTree().getSuperInterfaces();
        // create array to store reified subtree(s)
        superInterfaces = new Type[ts.length];
        // reify all subtrees
        for (int i = 0; i < ts.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ts[i].accept(r);// reify subtree
            // extract result from visitor and store it
            superInterfaces[i] = r.getResult();
        }
        this.superInterfaces = superInterfaces;
    }
    return superInterfaces.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
/**
 * Return the formal type parameters of this generic declaration.
 * @return the formal type parameters of this generic declaration
 */
public TypeVariable<?>[] getTypeParameters(){
    TypeVariable[] typeParams = this.typeParams;
    if (typeParams == null) { // lazily initialize type parameters
        // first, extract type parameter subtree(s) from AST
        FormalTypeParameter[] ftps = getTree().getFormalTypeParameters();
        // create array to store reified subtree(s)
        TypeVariable<?>[] tps = new TypeVariable<?>[ftps.length];
        // reify all subtrees
        for (int i = 0; i < ftps.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ftps[i].accept(r); // reify subtree
            // extract result from visitor and store it
            tps[i] = (TypeVariable<?>) r.getResult();
        }
        typeParams = tps; // cache overall result
        this.typeParams = typeParams;
    }
    return typeParams.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
/**
 * Return the formal type parameters of this generic declaration.
 * @return the formal type parameters of this generic declaration
 */
public TypeVariable/*<?>*/[] getTypeParameters(){
    if (typeParams == null) { // lazily initialize type parameters
        // first, extract type parameter subtree(s) from AST
        FormalTypeParameter[] ftps = getTree().getFormalTypeParameters();
        // create array to store reified subtree(s)
        TypeVariable[] tps = new TypeVariable[ftps.length];
        // reify all subtrees
        for (int i = 0; i < ftps.length; i++) {
            Reifier r = getReifier(); // obtain visitor
            ftps[i].accept(r); // reify subtree
            // extract result from visitor and store it
            tps[i] = (TypeVariable<?>) r.getResult();
        }
        typeParams = tps; // cache overall result
    }
    return typeParams.clone(); // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
private static Class<?> parseSig(String sig, Class container) {
    if (sig.equals("V")) return void.class;
    SignatureParser parser = SignatureParser.make();
    TypeSignature typeSig = parser.parseTypeSig(sig);
    GenericsFactory factory = CoreReflectionFactory.make(container, ClassScope.make(container));
    Reifier reify = Reifier.make(factory);
    typeSig.accept(reify);
    Type result = reify.getResult();
    return toClass(result);
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type getReturnType() {
    if (returnType == null) { // lazily initialize return type
        Reifier r = getReifier(); // obtain visitor
        // Extract return type subtree from AST and reify
        getTree().getReturnType().accept(r);
        // extract result from visitor and cache it
        returnType = r.getResult();
        }
    return returnType; // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
private Type[] computeExceptionTypes() {
    // first, extract exception type subtree(s) from AST
    FieldTypeSignature[] ets = getTree().getExceptionTypes();
    // create array to store reified subtree(s)
    int length = ets.length;
    Type[] exceptionTypes = new Type[length];
    // reify all subtrees
    for (int i = 0; i < length; i++) {
        Reifier r = getReifier(); // obtain visitor
        ets[i].accept(r); // reify subtree
        // extract result from visitor and store it
        exceptionTypes[i] = r.getResult();
    }
    return exceptionTypes;
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type getGenericType(){
    if (genericType == null) { // lazily initialize generic type
        Reifier r = getReifier(); // obtain visitor
        getTree().accept(r); // reify subtree
        // extract result from visitor and cache it
        genericType = r.getResult();
    }
    return genericType; // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
private static Class<?> parseSig(String sig, Class<?> container) {
    if (sig.equals("V")) return void.class;
    SignatureParser parser = SignatureParser.make();
    TypeSignature typeSig = parser.parseTypeSig(sig);
    GenericsFactory factory = CoreReflectionFactory.make(container, ClassScope.make(container));
    Reifier reify = Reifier.make(factory);
    typeSig.accept(reify);
    Type result = reify.getResult();
    return toClass(result);
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
public Type getSuperclass() {
    Type superclass = this.superclass;
    if (superclass == null) { // lazily initialize superclass
        Reifier r = getReifier(); // obtain visitor
        // Extract superclass subtree from AST and reify
        getTree().getSuperclass().accept(r);
        // extract result from visitor and cache it
        superclass = r.getResult();
        this.superclass = superclass;
    }
    return superclass; // return cached result
}
 

import sun.reflect.generics.visitor.Reifier; //导入方法依赖的package包/类
Type[] reifyBounds(FieldTypeSignature[] boundASTs) {
    final int length = boundASTs.length;
    final Type[] bounds = new Type[length];
    // iterate over bound trees, reifying each in turn
    for (int i = 0; i < length; i++) {
        Reifier r = getReifier();
        boundASTs[i].accept(r);
        bounds[i] = r.getResult();
    }
    return bounds;
}