Module org.htmlunit.corejs

Package org.htmlunit.corejs.javascript.lc.type

Interface TypeInfoFactory

All Superinterfaces:

Serializable

All Known Subinterfaces:

FactoryBase

All Known Implementing Classes:

AbstractCacheFactory, ClassValueCacheFactory, ClassValueCacheFactory.Concurrent, ClassValueCacheFactory.WeakReference, LegacyCacheFactory, LegacyCacheFactory.Concurrent, LegacyCacheFactory.WeakReference

public interface TypeInfoFactory
extends Serializable

Factory for TypeInfo

For getting TypeInfo representing a Type, use create(Type) and its overloads

For mutating an existed TypeInfo, use toArray(TypeInfo), attachParam(TypeInfo, TypeInfo...). These methods will not modify the original TypeInfo

This class is serializable, but cached TypeInfo (if implementation has a cache) will not be de/serialized

Author:

ZZZank

Field Summary

Fields

Modifier and Type	Field	Description
static final TypeInfo[]	EMPTY_ARRAY
static final TypeInfoFactory	GLOBAL	TypeInfoFactory used by scope independent actions.

Method Summary

Modifier and Type	Method	Description
default TypeInfoFactory	associate(TopLevel topScope)	Associate this TypeInfoFactory object with the given top-level scope.
TypeInfo	attachParam(TypeInfo base, List<TypeInfo> params)	In general, implementations are recommended, but not required, to return a ParameterizedTypeInfo.
default TypeInfo	attachParam(TypeInfo base, TypeInfo... params)
static List<TypeInfo>	consolidateAll(List<TypeInfo> types, Map<VariableTypeInfo,TypeInfo> mapping)	Transform provided types by applying TypeInfo.consolidate(Map) on its elements
default TypeInfo	consolidateType(TypeInfo type, TypeInfo consolidateHint)	consolidate a type using the mapping extracted from consolidateHint
TypeInfo	create(Class<?> clazz)
TypeInfo	create(GenericArrayType genericArrayType)
TypeInfo	create(ParameterizedType parameterizedType)
default TypeInfo	create(Type type)	create a TypeInfo from Type.
TypeInfo	create(TypeVariable<?> typeVariable)
TypeInfo	create(WildcardType wildcardType)
default <T extends Type> TypeInfo[]	createArray(T[] types)
default <T extends Type> List<TypeInfo>	createList(T[] types)
static TypeInfoFactory	get(VarScope scope)	Search for TypeInfoFactory in the given scope.
default Map<VariableTypeInfo,TypeInfo>	getConsolidationMapping(Class<?> from)	Get consolidation mapping from the input class.
static TypeInfoFactory	getOrElse(VarScope scope, TypeInfoFactory fallback)	Search for TypeInfoFactory in the given scope.
static TypeInfo	matchPredefined(Class<?> clazz)
TypeInfo	toArray(TypeInfo component)
static Map<VariableTypeInfo,TypeInfo>	transformMapping(Map<VariableTypeInfo,TypeInfo> mapping, Map<VariableTypeInfo,TypeInfo> transformer)	Transform a mapping by applying TypeInfo.consolidate(Map) on its values.

Field Details

GLOBAL

static final TypeInfoFactory GLOBAL

TypeInfoFactory used by scope independent actions.

This factory will cache TypeInfo. TypeInfo created from simple types like TypeInfoFactory.class will be kept in a cache, so that when the same type is passed to this factory, no new TypeInfo is created.

This factory is weakly referencing cached types. It holds a WeakReference to the type for each cached type, and will not prevent cached types from being unloaded

For actions with scope available, the TypeInfoFactory can be obtained via get(VarScope).

EMPTY_ARRAY

static final TypeInfo[] EMPTY_ARRAY

Method Details

create

TypeInfo create(Class<?> clazz)

create

TypeInfo create(GenericArrayType genericArrayType)

create

TypeInfo create(TypeVariable<?> typeVariable)

create

TypeInfo create(ParameterizedType parameterizedType)

create

TypeInfo create(WildcardType wildcardType)

toArray

TypeInfo toArray(TypeInfo component)

Returns:

a TypeInfo representing an array type whose component type is the provided component param

See Also:

• TypeInfo.isArray()
• TypeInfo.getComponentType()

attachParam

TypeInfo attachParam(TypeInfo base,
 List<TypeInfo> params)

In general, implementations are recommended, but not required, to return a ParameterizedTypeInfo.

Default implementations in Rhino will return a TypeInfo representing a parameterized type with raw type being base param, and parameters being params param. If the base param itself is already a ParameterizedTypeInfo, the raw type will then be ParameterizedTypeInfo.rawType() of base

See Also:

• ParameterizedTypeInfo

attachParam

default TypeInfo attachParam(TypeInfo base,
 TypeInfo... params)

getConsolidationMapping

default Map<VariableTypeInfo,TypeInfo> getConsolidationMapping(Class<?> from)

Get consolidation mapping from the input class.

Example (for factory implemented by Rhino):

 class A<Ta> {}
 class B<Tb> extends A<Tb> {}

 interface C<Tc> {}
 interface D<Td> extends C<Td> {}

 class E<Te> extends B<Te> implements D<String> {}
 

and input class is E.class. The result mapping will then be: Ta -> Te, Tb -> Te, Tc -> String, Td -> String

See Also:

• TypeInfo.consolidate(Map)

consolidateType

default TypeInfo consolidateType(TypeInfo type,
 TypeInfo consolidateHint)

consolidate a type using the mapping extracted from consolidateHint

Example: type is E in List<E>, consolidateHint is ArrayList<SomeRandomType>, result (for factories that support Java Generic) should then be SomeRandomType

See Also:

• TypeInfo.consolidate(Map)
• getConsolidationMapping(Class)
• ParameterizedTypeInfo.extractConsolidationMapping(TypeInfoFactory)

consolidateAll

static List<TypeInfo> consolidateAll(List<TypeInfo> types,
 Map<VariableTypeInfo,TypeInfo> mapping)

Transform provided types by applying TypeInfo.consolidate(Map) on its elements

Example: types is [int, E], mapping is E -> String, return value will then be [int, String]

transformMapping

static Map<VariableTypeInfo,TypeInfo> transformMapping(Map<VariableTypeInfo,TypeInfo> mapping,
 Map<VariableTypeInfo,TypeInfo> transformer)

Transform a mapping by applying TypeInfo.consolidate(Map) on its values.

Example: mapping is K -> V, transformer is V -> String, return value will then be K -> String

create

default TypeInfo create(Type type)

create a TypeInfo from Type.

Implementations are recommended, but not required, to maintain the uniqueness of simple types like Class, to reduce allocation

There's no guarantee that created TypeInfo will keep all their original information. For example, WildcardType might be mapped to one of its bounds, instead of a WildcardTypeInfo

Implementations should return TypeInfo.NONE if it's unable to parse the Type it received

createArray

default <T extends Type> TypeInfo[] createArray(T[] types)

createList

default <T extends Type> List<TypeInfo> createList(T[] types)

matchPredefined

static TypeInfo matchPredefined(Class<?> clazz)

associate

default TypeInfoFactory associate(TopLevel topScope)

Associate this TypeInfoFactory object with the given top-level scope.

NOTE: If you're about associate a custom TypeInfoFactory to a scope, call this method before initStandardObjects(...) or initSafeStandardObjects(...)

Parameters:

topScope - scope to associate this TypeInfoFactory object with.

Returns:

this if no previous TypeInfoFactory object was associated with the scope and this TypeInfoFactory is successfully associated, or the old associated factory otherwise.

Throws:

IllegalArgumentException - if provided scope is not top scope

See Also:

• get(VarScope scope)

get

static TypeInfoFactory get(VarScope scope)

Search for TypeInfoFactory in the given scope.

Parameters:

scope - scope to search for TypeInfoFactory object.

Returns:

previously associated TypeInfoFactory object.

Throws:

IllegalArgumentException - if the top scope of provided scope have no associated TypeInfoFactory.

See Also:

• associate(TopLevel topScope)

getOrElse

static TypeInfoFactory getOrElse(VarScope scope,
 TypeInfoFactory fallback)

Search for TypeInfoFactory in the given scope. When none was found, fallback is returned instead

Parameters:

scope - scope to search for TypeInfoFactory object.

Returns:

previously associated TypeInfoFactory object, or fallback if none was found

See Also:

• get(VarScope)
• associate(TopLevel topScope)