Java TypeToken.of方法代码示例

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
/**
 * Makes a MergedHandlerBuilder for a super event class
 *
 * @param superClass   the abstract super event class
 * @param priority     the priority to listen at
 * @param eventClasses the event classes to be bound to
 * @param <S>          the super class type
 * @return a {@link MergedSubscriptionBuilder} to construct the event handler
 */
@Nonnull
@SafeVarargs
static <S extends Event> MergedSubscriptionBuilder<S> newBuilder(@Nonnull Class<S> superClass, @Nonnull EventPriority priority, @Nonnull Class<? extends S>... eventClasses) {
    Preconditions.checkNotNull(superClass, "superClass");
    Preconditions.checkNotNull(eventClasses, "eventClasses");
    Preconditions.checkNotNull(priority, "priority");
    if (eventClasses.length < 2) {
        throw new IllegalArgumentException("merge method used for only one subclass");
    }

    MergedBuilder<S> h = new MergedBuilder<>(TypeToken.of(superClass));
    for (Class<? extends S> clazz : eventClasses) {
        h.bindEvent(clazz, priority, e -> e);
    }
    return h;
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
/**
 * A metadata marshaller that encodes objects as JSON using the google-gson library.
 *
 * <p>All non-ascii characters are unicode escaped to comply with {@code AsciiMarshaller}'s character range
 * requirements.
 *
 * @param clazz the type to serialize
 * @param <T>
 */
public static final <T> Metadata.AsciiMarshaller<T> JSON_MARSHALLER(Class<T> clazz) {
    return new Metadata.AsciiMarshaller<T>() {
        TypeToken<T> typeToken = TypeToken.of(clazz);
        private Gson gson = new Gson();

        @Override
        public String toAsciiString(T value) {
            try {
                try (StringWriter sw = new StringWriter()) {
                    gson.toJson(value, typeToken.getType(), new UnicodeEscapingAsciiWriter(sw));
                    return sw.toString();
                }
            } catch (IOException e) {
                throw new IllegalArgumentException(e);
            }
        }

        @Override
        public T parseAsciiString(String serialized) {
            return gson.fromJson(serialized, typeToken.getType());
        }
    };
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
public static ReflectiveProperty of(Field field, Inspectable.Inspect annotation) {
    field.setAccessible(true);
    return new ReflectiveProperty(
        annotation.name().length() > 0 ? annotation.name()
                                       : field.getName(),
        TypeToken.of(field.getGenericType()),
        new Inspection(annotation),
        MethodHandleUtils.privateUnreflectGetter(field)
    );
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
private static TypeToken<?> getFirstTypeParameter(Type type) {
  if (type instanceof ParameterizedType) {
    return TypeToken.of(
        ((ParameterizedType) type).getActualTypeArguments()[0]);
  } else {
    return TypeToken.of(Object.class);
  }
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
@Override
public Object getParameterValue(Parameter parameter) {
  TypeToken<?> parameterType = TypeToken.of(parameter.getParameterizedType());
  TypeToken<?> captorParameter =
      parameterType.resolveType(ArgumentCaptor.class.getTypeParameters()[0]);
  return ArgumentCaptor.forClass(captorParameter.getRawType());
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Object convert(Object input, ParameterContext context) throws ArgumentConversionException {
  TypeToken<?> parameterType = TypeToken.of(context.getParameter().getParameterizedType());
  if (parameterType.getRawType() != Class.class) {
    throw new ArgumentConversionException(
        String.format("Could not convert: %s. Invalid parameter type.", input));
  }

  return convert(input.toString(), (TypeToken<? extends Class<?>>) parameterType);
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
private static Key<?> getKey(Optional<Class<?>> containingElement, Parameter parameter) {
  Class<?> clazz =
      containingElement.orElseGet(() -> parameter.getDeclaringExecutable().getDeclaringClass());
  TypeToken<?> classType = TypeToken.of(clazz);
  Type resolvedType = classType.resolveType(parameter.getParameterizedType()).getType();

  Optional<Key<?>> key =
      getOnlyBindingAnnotation(parameter).map(annotation -> Key.get(resolvedType, annotation));
  return key.orElse(Key.get(resolvedType));
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
public GsonStorageHandler(String fileName, String fileExtension, File dataFolder, Class<T> clazz) {
    this(fileName, fileExtension, dataFolder, TypeToken.of(clazz));
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
protected BaseFieldKey(String name, boolean nullable, Class<T> valueType, FieldGeneratorType fieldGeneratorType){
	this(name, nullable, TypeToken.of(valueType), fieldGeneratorType);
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
public DelegateCodec(ThriftCodecManager codecManager, Type javaType)
{
    this.codecManager = codecManager;
    this.typeToken = (TypeToken<T>) TypeToken.of(javaType);
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
private Object writeReplace() {
  return new DummyHandler(TypeToken.of(interfaceType.getRawType()));
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
@Generates private TypeToken<?> generateTypeToken() {
  return TypeToken.of(generateClass());
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
public FindRequest(@Nullable Class<T> model) {
    this(model == null ? null : TypeToken.of(model));
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
public <T> TypeToken<T> resolve(TypeToken<T> type) {
    return (TypeToken<T>) TypeToken.of(resolver.resolveType(type.getType()));
}
 

import com.google.common.reflect.TypeToken; //导入方法依赖的package包/类
/**
 * Convert a Guice {@link TypeLiteral} to a Guava {@link TypeToken}
 */
public static <T> TypeToken<T> toToken(TypeLiteral<T> typeLiteral) {
    return (TypeToken<T>) TypeToken.of(typeLiteral.getType());
}