Java ParameterizedType.getOwnerType方法代码示例

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Returns a type that is functionally equal but not necessarily equal according to {@link
 * Object#equals(Object) Object.equals()}.
 */
static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

  } else if (type instanceof ParameterizedType) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    if (type instanceof GenericArrayTypeImpl) return type;
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    if (type instanceof WildcardTypeImpl) return type;
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    return type; // This type is unsupported!
  }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
static String toStringPT(ParameterizedType pt) {
    StringBuilder sb = new StringBuilder();
    Type ownerType = pt.getOwnerType();
    Class<?> rawType = (Class<?>) pt.getRawType();
    Type[] actualTypeArguments = pt.getActualTypeArguments();
    sb.append(rawType.getName().replace('$', '.'));

    if (actualTypeArguments != null && actualTypeArguments.length > 0) {
        sb.append("<");
        boolean first = true;
        for (Type t : actualTypeArguments) {
            if (!first)
                sb.append(", ");
            sb.append(((Class<?>) t).getName());
            first = false;
        }
        sb.append(">");
    }

    return sb.toString();
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public Type onParameterizdType(ParameterizedType p, BinderArg args) {
    Type[] params = p.getActualTypeArguments();

    boolean different = false;
    for (int i = 0; i < params.length; i++) {
        Type t = params[i];
        params[i] = visit(t, args);
        different |= t != params[i];
    }

    Type newOwner = p.getOwnerType();
    if (newOwner != null) {
        newOwner = visit(newOwner, args);
    }
    different |= p.getOwnerType() != newOwner;

    if (!different) {
        return p;
    }

    return new ParameterizedTypeImpl((Class<?>) p.getRawType(), params, newOwner);
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Returns a type that is functionally equal but not necessarily equal according to {@link
 * Object#equals(Object) Object.equals()}.
 */
private static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;
  } else if (type instanceof ParameterizedType) {
    if (type instanceof ParameterizedTypeImpl) return type;
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
      p.getRawType(), p.getActualTypeArguments());
  } else if (type instanceof GenericArrayType) {
    if (type instanceof GenericArrayTypeImpl) return type;
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());
  } else if (type instanceof WildcardType) {
    if (type instanceof WildcardTypeImpl) return type;
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());
  } else {
    return type; // This type is unsupported!
  }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public void testGetSubtype_recursiveTypeBoundInSubtypeTranslatedAsIs() {
  class BaseWithTypeVar<T> {}
  class Outer<O> {
    class Sub<X> extends BaseWithTypeVar<List<X>> {}
    class Sub2<Y extends Sub2<Y>> extends BaseWithTypeVar<List<Y>> {}
  }
  ParameterizedType subtype = (ParameterizedType) new TypeToken<BaseWithTypeVar<List<?>>>() {}
          .getSubtype(Outer.Sub.class)
          .getType();
  assertEquals(Outer.Sub.class, subtype.getRawType());
  assertThat(subtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class);
  ParameterizedType owner = (ParameterizedType) subtype.getOwnerType();
  assertEquals(Outer.class, owner.getRawType());
  // This returns a strange ? extends Sub2<Y> type, which isn't ideal.
  TypeToken<?> unused = new TypeToken<BaseWithTypeVar<List<?>>>() {}.getSubtype(Outer.Sub2.class);
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public static boolean isFullySpecified(Type type) {
    checkNotNull(type);
    if(type instanceof Class) {
        return true;
    } else if(type instanceof TypeVariable) {
        return false;
    } else if(type instanceof GenericArrayType) {
        return isFullySpecified(((GenericArrayType) type).getGenericComponentType());
    } else if(type instanceof WildcardType) {
        final WildcardType wildcard = (WildcardType) type;
        return Stream.of(wildcard.getLowerBounds()).allMatch(Types::isFullySpecified) &&
               Stream.of(wildcard.getUpperBounds()).allMatch(Types::isFullySpecified);
    } else if(type instanceof ParameterizedType) {
        final ParameterizedType parameterized = (ParameterizedType) type;
        return isFullySpecified(parameterized.getRawType()) &&
               (parameterized.getOwnerType() == null || isFullySpecified(parameterized.getOwnerType())) &&
               Stream.of(parameterized.getActualTypeArguments()).allMatch(Types::isFullySpecified);
    } else {
        throw new IllegalArgumentException("Unhandled metatype " + type.getClass());
    }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public static Type canonicalize(Type type) {
    if (type instanceof Class) {
        Class<?> c = (Class) type;
        return c.isArray() ? new GenericArrayTypeImpl(C$Gson$Types.canonicalize(c.getComponentType())) : c;
    } else if (type instanceof ParameterizedType) {
        ParameterizedType p = (ParameterizedType) type;
        return new ParameterizedTypeImpl(p.getOwnerType(), p.getRawType(), p.getActualTypeArguments());
    } else if (type instanceof GenericArrayType) {
        return new GenericArrayTypeImpl(((GenericArrayType) type).getGenericComponentType());
    } else {
        if (!(type instanceof WildcardType)) {
            return type;
        }
        WildcardType w = (WildcardType) type;
        return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());
    }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private boolean isSubtypeOfParameterizedType(ParameterizedType supertype) {
  Class<?> matchedClass = of(supertype).getRawType();
  if (!someRawTypeIsSubclassOf(matchedClass)) {
    return false;
  }
  Type[] typeParams = matchedClass.getTypeParameters();
  Type[] toTypeArgs = supertype.getActualTypeArguments();
  for (int i = 0; i < typeParams.length; i++) {
    // If 'supertype' is "List<? extends CharSequence>"
    // and 'this' is StringArrayList,
    // First step is to figure out StringArrayList "is-a" List<E> and <E> is
    // String.
    // typeParams[0] is E and fromTypeToken.get(typeParams[0]) will resolve to
    // String.
    // String is then matched against <? extends CharSequence>.
    if (!resolveType(typeParams[i]).is(toTypeArgs[i])) {
      return false;
    }
  }
  // We only care about the case when the supertype is a non-static inner class
  // in which case we need to make sure the subclass's owner type is a subtype of the
  // supertype's owner.
  return Modifier.isStatic(((Class<?>) supertype.getRawType()).getModifiers())
      || supertype.getOwnerType() == null
      || isOwnedBySubtypeOf(supertype.getOwnerType());
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Returns a type that is functionally equal but not necessarily equal
 * according to {@link Object#equals(Object) Object.equals()}. The returned
 * type is {@link java.io.Serializable}.
 */
public static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

  } else if (type instanceof ParameterizedType) {
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    // type is either serializable as-is or unsupported
    return type;
  }
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private static boolean getArgument(Type[] typeArgs, TypeVariable[] typeVariables, Type[] arguments) {
    if (arguments == null || typeVariables.length == 0) {
        return false;
    }

    boolean changed = false;
    for (int i = 0; i < typeArgs.length; ++i) {
        Type typeArg = typeArgs[i];
        if (typeArg instanceof ParameterizedType) {
            ParameterizedType p_typeArg = (ParameterizedType) typeArg;
            Type[] p_typeArg_args = p_typeArg.getActualTypeArguments();
            boolean p_changed = getArgument(p_typeArg_args, typeVariables, arguments);
            if (p_changed) {
                typeArgs[i] = new ParameterizedTypeImpl(p_typeArg_args, p_typeArg.getOwnerType(), p_typeArg.getRawType());
                changed = true;
            }
        } else if (typeArg instanceof TypeVariable) {
            for (int j = 0; j < typeVariables.length; ++j) {
                if (typeArg.equals(typeVariables[j])) {
                    typeArgs[i] = arguments[j];
                    changed = true;
                }
            }
        }
    }

    return changed;
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private static ClassOwnership detectJvmBehavior() {
  class LocalClass<T> {}
  Class<?> subclass = new LocalClass<String>() {}.getClass();
  ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass();
  for (ClassOwnership behavior : ClassOwnership.values()) {
    if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) {
      return behavior;
    }
  }
  throw new AssertionError();
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
private ParameterizedType resolveParameterizedType(ParameterizedType type) {
  Type owner = type.getOwnerType();
  Type resolvedOwner = (owner == null) ? null : resolveType(owner);
  Type resolvedRawType = resolveType(type.getRawType());

  Type[] args = type.getActualTypeArguments();
  Type[] resolvedArgs = resolveTypes(args);
  return Types.newParameterizedTypeWithOwner(
      resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs);
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
public void testGetSubtype_innerTypeOfGenericClassTranslatesOwnerTypeVars() {
  TypeToken<TwoTypeArgs<?, ?>.InnerType<?, ?>> supertype =
      new TypeToken<TwoTypeArgs<?, ?>.InnerType<?, ?>>() {};
  TypeToken<StringForFirstTypeArg<Integer>.StringInnerType<Long>> subtype =
      new TypeToken<StringForFirstTypeArg<Integer>.StringInnerType<Long>>() {};
  assertTrue(subtype.isSubtypeOf(supertype));
  ParameterizedType actualSubtype = (ParameterizedType)
      supertype.getSubtype(subtype.getRawType()).getType();
  assertEquals(StringForFirstTypeArg.StringInnerType.class, actualSubtype.getRawType());
  assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class);
  ParameterizedType actualOwnerType = (ParameterizedType) actualSubtype.getOwnerType();
  assertEquals(StringForFirstTypeArg.class, actualOwnerType.getRawType());
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
@Override
public boolean equals(Object o) {
    if (o instanceof ParameterizedType) {
        // Check that information is equivalent
        ParameterizedType that = (ParameterizedType) o;

        if (this == that)
            return true;

        Type thatOwner   = that.getOwnerType();
        Type thatRawType = that.getRawType();

        if (false) { // Debugging
            boolean ownerEquality = (ownerType == null ?
                                     thatOwner == null :
                                     ownerType.equals(thatOwner));
            boolean rawEquality = (rawType == null ?
                                   thatRawType == null :
                                   rawType.equals(thatRawType));

            boolean typeArgEquality = Arrays.equals(actualTypeArguments, // avoid clone
                                                    that.getActualTypeArguments());
            for (Type t : actualTypeArguments) {
                System.out.printf("\t\t%s%s%n", t, t.getClass());
            }

            System.out.printf("\towner %s\traw %s\ttypeArg %s%n",
                              ownerEquality, rawEquality, typeArgEquality);
            return ownerEquality && rawEquality && typeArgEquality;
        }

        return
            Objects.equals(ownerType, thatOwner) &&
            Objects.equals(rawType, thatRawType) &&
            Arrays.equals(actualTypeArguments, // avoid clone
                          that.getActualTypeArguments());
    } else
        return false;
}
 

import java.lang.reflect.ParameterizedType; //导入方法依赖的package包/类
/**
 * Returns a type that is functionally equal but not necessarily equal
 * according to {@link Object#equals(Object) Object.equals()}. The returned
 * type is {@link Serializable}.
 */
public static Type canonicalize(Type type) {
  if (type instanceof Class) {
    Class<?> c = (Class<?>) type;
    return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;

  } else if (type instanceof CompositeType) {
    return type;

  } else if (type instanceof ParameterizedType) {
    ParameterizedType p = (ParameterizedType) type;
    return new ParameterizedTypeImpl(p.getOwnerType(),
        p.getRawType(), p.getActualTypeArguments());

  } else if (type instanceof GenericArrayType) {
    GenericArrayType g = (GenericArrayType) type;
    return new GenericArrayTypeImpl(g.getGenericComponentType());

  } else if (type instanceof WildcardType) {
    WildcardType w = (WildcardType) type;
    return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());

  } else {
    // type is either serializable as-is or unsupported
    return type;
  }
}