sun.reflect.generics.factory.GenericsFactory Java Examples

private WildcardTypeImpl(FieldTypeSignature[] ubs,
                         FieldTypeSignature[] lbs,
                         GenericsFactory f) {
    super(f);
    upperBoundASTs = ubs;
    lowerBoundASTs = lbs;
}
 

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);
}
 

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);
}
 

/**
 * Factory method.
 * @param decl - the reflective object that declared the type variable
 * that this method should create
 * @param name - the name of the type variable to be returned
 * @param bs - an array of ASTs representing the bounds for the type
 * variable to be created
 * @param f - a factory that can be used to manufacture reflective
 * objects that represent the bounds of this type variable
 * @return A type variable with name, bounds, declaration and factory
 * specified
 */
public static <T extends GenericDeclaration>
                         TypeVariableImpl<T> make(T decl, String name,
                                                  FieldTypeSignature[] bs,
                                                  GenericsFactory f) {

    if (!((decl instanceof Class) ||
            (decl instanceof Method) ||
            (decl instanceof Constructor))) {
        throw new AssertionError("Unexpected kind of GenericDeclaration" +
                decl.getClass().toString());
    }
    return new TypeVariableImpl<T>(decl, name, bs, f);
}
 

/**
 * Factory method.
 * @param decl - the reflective object that declared the type variable
 * that this method should create
 * @param name - the name of the type variable to be returned
 * @param bs - an array of ASTs representing the bounds for the type
 * variable to be created
 * @param f - a factory that can be used to manufacture reflective
 * objects that represent the bounds of this type variable
 * @return A type variable with name, bounds, declaration and factory
 * specified
 */
public static <T extends GenericDeclaration>
                         TypeVariableImpl<T> make(T decl, String name,
                                                  FieldTypeSignature[] bs,
                                                  GenericsFactory f) {

    if (!((decl instanceof Class) ||
            (decl instanceof Method) ||
            (decl instanceof Constructor))) {
        throw new AssertionError("Unexpected kind of GenericDeclaration" +
                decl.getClass().toString());
    }
    return new TypeVariableImpl<T>(decl, name, bs, f);
}
 

private TypeVariableImpl(D decl, String n, FieldTypeSignature[] bs,
                         GenericsFactory f) {
    super(f);
    genericDeclaration = decl;
    name = n;
    boundASTs = bs;
}
 

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);
}
 

private TypeVariableImpl(D decl, String n, FieldTypeSignature[] bs,
                         GenericsFactory f) {
    super(f);
    genericDeclaration = decl;
    name = n;
    boundASTs = bs;
}
 

private WildcardTypeImpl(FieldTypeSignature[] ubs,
                         FieldTypeSignature[] lbs,
                         GenericsFactory f) {
    super(f);
    upperBoundASTs = ubs;
    lowerBoundASTs = lbs;
}
 

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);
}
 

protected FieldRepository(String rawSig, GenericsFactory f) {
  super(rawSig, f);
}
 

protected LazyReflectiveObjectGenerator(GenericsFactory f) {
    factory = f;
}
 

private GenericsFactory getFactory() {
    return factory;
}
 

private GenericsFactory getFactory() {
    // create scope and factory
    return CoreReflectionFactory.make(this, ClassScope.make(this));
}
 

private GenericsFactory getFactory() {
    // create scope and factory
    return CoreReflectionFactory.make(this, ConstructorScope.make(this));
}
 

private GenericsFactory getFactory() {
    // create scope and factory
    return CoreReflectionFactory.make(this, MethodScope.make(this));
}
 

private GenericsFactory getFactory() {
    Class<?> c = getDeclaringClass();
    // create scope and factory
    return CoreReflectionFactory.make(c, ClassScope.make(c));
}
 

private ClassRepository(String rawSig, GenericsFactory f) {
    super(rawSig, f);
}
 

protected ConstructorRepository(String rawSig, GenericsFactory f) {
  super(rawSig, f);
}
 

private GenericsFactory getFactory() {
    // create scope and factory
    return CoreReflectionFactory.make(this, ClassScope.make(this));
}
 

private GenericsFactory getFactory() {
    return factory;
}
 

protected GenericDeclRepository(String rawSig, GenericsFactory f) {
    super(rawSig, f);
}
 

protected FieldRepository(String rawSig, GenericsFactory f) {
  super(rawSig, f);
}
 

protected GenericDeclRepository(String rawSig, GenericsFactory f) {
    super(rawSig, f);
}
 

private GenericsFactory getFactory() {
    return factory;
}
 

private ClassRepository(String rawSig, GenericsFactory f) {
    super(rawSig, f);
}
 

private GenericsFactory getFactory() {
    // create scope and factory
    return CoreReflectionFactory.make(this, ClassScope.make(this));
}
 

private ClassRepository(String rawSig, GenericsFactory f) {
    super(rawSig, f);
}
 

private GenericsFactory getFactory() {
    Class<?> c = getDeclaringClass();
    // create scope and factory
    return CoreReflectionFactory.make(c, ClassScope.make(c));
}
 

private MethodRepository(String rawSig, GenericsFactory f) {
  super(rawSig, f);
}