org.htmlunit.corejs.javascript.lc.type

Interface TypeInfoFactory

All Superinterfaces:

Serializable

All Known Subinterfaces:

FactoryBase

All Known Implementing Classes:

ConcurrentFactory, NoCacheFactory, WeakReferenceFactory, WithCacheFactory

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 and Description
static TypeInfo[]	EMPTY_ARRAY
static TypeInfoFactory	GLOBAL TypeInfoFactory used by scope independent actions.
static TypeInfoFactory	NO_CACHE TypeInfoFactory used by very few actions with the intention of not caching any used types This factory does not cache TypeInfo.

Method Summary

Modifier and Type	Method and Description
default TypeInfoFactory	associate(ScriptableObject 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)
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(Scriptable scope) Search for TypeInfoFactory in the given scope.
default Map<VariableTypeInfo,TypeInfo>	getConsolidationMapping(Class<?> from)
static TypeInfoFactory	getOrElse(Scriptable scope, TypeInfoFactory fallback) Search for TypeInfoFactory in the given scope.
static TypeInfo	matchPredefined(Class<?> clazz)
TypeInfo	toArray(TypeInfo component)

Field Detail

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(Scriptable).

NO_CACHE

static final TypeInfoFactory NO_CACHE

TypeInfoFactory used by very few actions with the intention of not caching any used types

This factory does not cache TypeInfo. If the same type is passed to this factory multiple times, the return result may or may not be the exact same object

EMPTY_ARRAY

static final TypeInfo[] EMPTY_ARRAY

Method Detail

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)

See Also:

TypeInfo.consolidate(Map)

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(ScriptableObject 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(Scriptable scope)

get

static TypeInfoFactory get(Scriptable 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(ScriptableObject topScope)

getOrElse

static TypeInfoFactory getOrElse(Scriptable 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(Scriptable), associate(ScriptableObject topScope)