org.springframework.core.SerializableTypeWrapper.TypeProvider Java Examples

/**
 * Private constructor used to create a new {@link ResolvableType} for cache key purposes,
 * with no upfront resolution.
 */
private ResolvableType(
		Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.hash = calculateHashCode();
	this.resolved = null;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache value purposes,
 * with upfront resolution and a pre-calculated hash.
 * @since 4.2
 */
private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
		@Nullable VariableResolver variableResolver, @Nullable Integer hash) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.hash = hash;
	this.resolved = resolveClass();
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for uncached purposes,
 * with upfront resolution but lazily calculated hash.
 */
private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
		@Nullable VariableResolver variableResolver, @Nullable ResolvableType componentType) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = componentType;
	this.hash = null;
	this.resolved = resolveClass();
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Type} backed by a given
 * {@link VariableResolver}.
 * @param type the source type or {@code null}
 * @param typeProvider the type provider or {@code null}
 * @param variableResolver the variable resolver or {@code null}
 * @return a {@link ResolvableType} for the specified {@link Type} and {@link VariableResolver}
 */
static ResolvableType forType(
		@Nullable Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

	if (type == null && typeProvider != null) {
		type = SerializableTypeWrapper.forTypeProvider(typeProvider);
	}
	if (type == null) {
		return NONE;
	}

	// For simple Class references, build the wrapper right away -
	// no expensive resolution necessary, so not worth caching...
	if (type instanceof Class) {
		return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
	}

	// Purge empty entries on access since we don't have a clean-up thread or the like.
	cache.purgeUnreferencedEntries();

	// Check the cache - we may have a ResolvableType which has been resolved before...
	ResolvableType resultType = new ResolvableType(type, typeProvider, variableResolver);
	ResolvableType cachedType = cache.get(resultType);
	if (cachedType == null) {
		cachedType = new ResolvableType(type, typeProvider, variableResolver, resultType.hash);
		cache.put(cachedType, cachedType);
	}
	resultType.resolved = cachedType.resolved;
	return resultType;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache key purposes,
 * with no upfront resolution.
 */
private ResolvableType(
		Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.hash = calculateHashCode();
	this.resolved = null;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache value purposes,
 * with upfront resolution and a pre-calculated hash.
 * @since 4.2
 */
private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
		@Nullable VariableResolver variableResolver, @Nullable Integer hash) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.hash = hash;
	this.resolved = resolveClass();
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for uncached purposes,
 * with upfront resolution but lazily calculated hash.
 */
private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
		@Nullable VariableResolver variableResolver, @Nullable ResolvableType componentType) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = componentType;
	this.hash = null;
	this.resolved = resolveClass();
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Type} backed by a given
 * {@link VariableResolver}.
 * @param type the source type or {@code null}
 * @param typeProvider the type provider or {@code null}
 * @param variableResolver the variable resolver or {@code null}
 * @return a {@link ResolvableType} for the specified {@link Type} and {@link VariableResolver}
 */
static ResolvableType forType(
		@Nullable Type type, @Nullable TypeProvider typeProvider, @Nullable VariableResolver variableResolver) {

	if (type == null && typeProvider != null) {
		type = SerializableTypeWrapper.forTypeProvider(typeProvider);
	}
	if (type == null) {
		return NONE;
	}

	// For simple Class references, build the wrapper right away -
	// no expensive resolution necessary, so not worth caching...
	if (type instanceof Class) {
		return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
	}

	// Purge empty entries on access since we don't have a clean-up thread or the like.
	cache.purgeUnreferencedEntries();

	// Check the cache - we may have a ResolvableType which has been resolved before...
	ResolvableType resultType = new ResolvableType(type, typeProvider, variableResolver);
	ResolvableType cachedType = cache.get(resultType);
	if (cachedType == null) {
		cachedType = new ResolvableType(type, typeProvider, variableResolver, resultType.hash);
		cache.put(cachedType, cachedType);
	}
	resultType.resolved = cachedType.resolved;
	return resultType;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache key purposes,
 * with no upfront resolution.
 */
private ResolvableType(Type type, TypeProvider typeProvider, VariableResolver variableResolver) {
	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.resolved = null;
	this.hash = calculateHashCode();
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache value purposes,
 * with upfront resolution and a pre-calculated hash.
 * @since 4.2
 */
private ResolvableType(Type type, TypeProvider typeProvider, VariableResolver variableResolver, Integer hash) {
	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.resolved = resolveClass();
	this.hash = hash;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for uncached purposes,
 * with upfront resolution but lazily calculated hash.
 */
private ResolvableType(
		Type type, TypeProvider typeProvider, VariableResolver variableResolver, ResolvableType componentType) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = componentType;
	this.resolved = resolveClass();
	this.hash = null;
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Type} backed by a given
 * {@link VariableResolver}.
 * @param type the source type or {@code null}
 * @param typeProvider the type provider or {@code null}
 * @param variableResolver the variable resolver or {@code null}
 * @return a {@link ResolvableType} for the specified {@link Type} and {@link VariableResolver}
 */
static ResolvableType forType(Type type, TypeProvider typeProvider, VariableResolver variableResolver) {
	if (type == null && typeProvider != null) {
		type = SerializableTypeWrapper.forTypeProvider(typeProvider);
	}
	if (type == null) {
		return NONE;
	}

	// For simple Class references, build the wrapper right away -
	// no expensive resolution necessary, so not worth caching...
	if (type instanceof Class) {
		return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
	}

	// Purge empty entries on access since we don't have a clean-up thread or the like.
	cache.purgeUnreferencedEntries();

	// Check the cache - we may have a ResolvableType which has been resolved before...
	ResolvableType key = new ResolvableType(type, typeProvider, variableResolver);
	ResolvableType resolvableType = cache.get(key);
	if (resolvableType == null) {
		resolvableType = new ResolvableType(type, typeProvider, variableResolver, key.hash);
		cache.put(resolvableType, resolvableType);
	}
	return resolvableType;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache key purposes,
 * with no upfront resolution.
 */
private ResolvableType(Type type, TypeProvider typeProvider, VariableResolver variableResolver) {
	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.resolved = null;
	this.hash = calculateHashCode();
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for cache value purposes,
 * with upfront resolution and a pre-calculated hash.
 * @since 4.2
 */
private ResolvableType(Type type, TypeProvider typeProvider, VariableResolver variableResolver, Integer hash) {
	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = null;
	this.resolved = resolveClass();
	this.hash = hash;
}
 

/**
 * Private constructor used to create a new {@link ResolvableType} for uncached purposes,
 * with upfront resolution but lazily calculated hash.
 */
private ResolvableType(
		Type type, TypeProvider typeProvider, VariableResolver variableResolver, ResolvableType componentType) {

	this.type = type;
	this.typeProvider = typeProvider;
	this.variableResolver = variableResolver;
	this.componentType = componentType;
	this.resolved = resolveClass();
	this.hash = null;
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Type} backed by a given
 * {@link VariableResolver}.
 * @param type the source type or {@code null}
 * @param typeProvider the type provider or {@code null}
 * @param variableResolver the variable resolver or {@code null}
 * @return a {@link ResolvableType} for the specified {@link Type} and {@link VariableResolver}
 */
static ResolvableType forType(Type type, TypeProvider typeProvider, VariableResolver variableResolver) {
	if (type == null && typeProvider != null) {
		type = SerializableTypeWrapper.forTypeProvider(typeProvider);
	}
	if (type == null) {
		return NONE;
	}

	// For simple Class references, build the wrapper right away -
	// no expensive resolution necessary, so not worth caching...
	if (type instanceof Class) {
		return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
	}

	// Purge empty entries on access since we don't have a clean-up thread or the like.
	cache.purgeUnreferencedEntries();

	// Check the cache - we may have a ResolvableType which has been resolved before...
	ResolvableType key = new ResolvableType(type, typeProvider, variableResolver);
	ResolvableType resolvableType = cache.get(key);
	if (resolvableType == null) {
		resolvableType = new ResolvableType(type, typeProvider, variableResolver, key.hash);
		cache.put(resolvableType, resolvableType);
	}
	return resolvableType;
}