TypeVariableTypeInformation (Lettuce 5.3.5.RELEASE API)

java.lang.Object
- io.lettuce.core.dynamic.support.TypeVariableTypeInformation<T>

All Implemented Interfaces:

TypeInformation<T>
```
public class TypeVariableTypeInformation<T>
extends Object
```
Special TypeDiscoverer to determine the actual type for a TypeVariable. Will consider the context the TypeVariable is being used in.

Constructor Summary

Constructors
Constructor and Description
`TypeVariableTypeInformation(TypeVariable<?> variable, Type owningType, io.lettuce.core.dynamic.support.TypeDiscoverer<?> parent, Map<TypeVariable<?>,Type> typeVariableMap)` Creates a bew `TypeVariableTypeInformation` for the given `TypeVariable` owning `Type` and parent `TypeDiscoverer`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected TypeInformation<?>`	`createInfo(Type fieldType)` Creates `TypeInformation` for the given `Type`.
`protected TypeInformation<?>`	`doGetComponentType()`
`protected TypeInformation<?>`	`doGetMapValueType()`
`boolean`	`equals(Object obj)`
`TypeInformation<?>`	`getActualType()` Transparently returns the `Map` value type if the type is a `Map`, returns the component type if the type `TypeInformation.isCollectionLike()` or the simple type if none of this applies.
`TypeInformation<?>`	`getComponentType()` Returns the component type for `Collection`s or the key type for `Map`s.
`Type`	`getGenericType()`
`TypeInformation<?>`	`getMapValueType()` Will return the type of the value in case the underlying type is a `Map`.
`List<TypeInformation<?>>`	`getParameterTypes(Constructor<?> constructor)` Returns the `TypeInformation`s for the parameters of the given `Constructor`.
`List<TypeInformation<?>>`	`getParameterTypes(Method method)` Returns the `TypeInformation`s for the parameters of the given `Method`.
`ClassTypeInformation<?>`	`getRawTypeInformation()` Returns a `ClassTypeInformation` to represent the `TypeInformation` of the raw type of the current instance.
`TypeInformation<?>`	`getReturnType(Method method)` Returns a `TypeInformation` for the return type of the given `Method`.
`TypeInformation<?>`	`getSuperTypeInformation(Class<?> superType)` Returns the `TypeInformation` for the given raw super type.
`Class<T>`	`getType()` Returns the type of the property.
`TypeInformation<?>`	`getTypeArgument(Class<?> bound, int index)`
`List<TypeInformation<?>>`	`getTypeArguments()` Returns the `TypeInformation` for the type arguments of the current `TypeInformation`.
`Map<TypeVariable<?>,Type>`	`getTypeVariableMap()` Returns the type variable map.
`String`	`getVariableName()`
`int`	`hashCode()`
`boolean`	`isAssignableFrom(TypeInformation<?> target)` Returns if the current `TypeInformation` can be safely assigned to the given one.
`boolean`	`isCollectionLike()` Returns whether the type can be considered a collection, which means it's a container of elements, e.g. a `Collection` and `Array` or anything implementing `Iterable`.
`boolean`	`isMap()` Returns whether the property is a `Map`.
`protected Class<S>`	`resolveClass(Type type)` Resolves the given type into a plain `Class`.
`protected Type`	`resolveType(Type type)` Resolves the given type into a `Type`.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - TypeVariableTypeInformation
```
public TypeVariableTypeInformation(TypeVariable<?> variable,
                                   Type owningType,
                                   io.lettuce.core.dynamic.support.TypeDiscoverer<?> parent,
                                   Map<TypeVariable<?>,Type> typeVariableMap)
```
    Creates a bew TypeVariableTypeInformation for the given TypeVariable owning Type and parent TypeDiscoverer.
    
    Parameters:
    
    variable - must not be null
    
    owningType - must not be null
    
    parent - can be be null
    
    typeVariableMap - must not be null
- Method Detail
  - getType
```
public Class<T> getType()
```
    Description copied from interface: TypeInformation
    
    Returns the type of the property. Will resolve generics and the generic context of
    
    Specified by:
    
    getType in interface TypeInformation<T>
    
    Returns:
  - getTypeArguments
```
public List<TypeInformation<?>> getTypeArguments()
```
    Description copied from interface: TypeInformation
    
    Returns the TypeInformation for the type arguments of the current TypeInformation.
    
    Specified by:
    
    getTypeArguments in interface TypeInformation<T>
    
    Returns:
  - equals
```
public boolean equals(Object obj)
```
  - hashCode
```
public int hashCode()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getVariableName
```
public String getVariableName()
```
  - createInfo
```
protected TypeInformation<?> createInfo(Type fieldType)
```
    Creates TypeInformation for the given Type.
    
    Returns:
  - getTypeVariableMap
```
public Map<TypeVariable<?>,Type> getTypeVariableMap()
```
    Returns the type variable map.
    
    Specified by:
    
    getTypeVariableMap in interface TypeInformation<S>
    
    Returns:
  - resolveClass
```
protected Class<S> resolveClass(Type type)
```
    Resolves the given type into a plain Class.
    
    Parameters:
    
    type -
    
    Returns:
  - resolveType
```
protected Type resolveType(Type type)
```
    Resolves the given type into a Type.
    
    Parameters:
    
    type -
    
    Returns:
  - getParameterTypes
```
public List<TypeInformation<?>> getParameterTypes(Constructor<?> constructor)
```
    Description copied from interface: TypeInformation
    
    Returns the TypeInformations for the parameters of the given Constructor.
    
    Specified by:
    
    getParameterTypes in interface TypeInformation<S>
    
    Parameters:
    
    constructor - must not be null.
    
    Returns:
  - getGenericType
```
public Type getGenericType()
```
    Specified by:
    
    getGenericType in interface TypeInformation<S>
  - getRawTypeInformation
```
public ClassTypeInformation<?> getRawTypeInformation()
```
    Description copied from interface: TypeInformation
    
    Returns a ClassTypeInformation to represent the TypeInformation of the raw type of the current instance.
    
    Specified by:
    
    getRawTypeInformation in interface TypeInformation<S>
    
    Returns:
  - getActualType
```
public TypeInformation<?> getActualType()
```
    Description copied from interface: TypeInformation
    
    Transparently returns the Map value type if the type is a Map, returns the component type if the type TypeInformation.isCollectionLike() or the simple type if none of this applies.
    
    Specified by:
    
    getActualType in interface TypeInformation<S>
    
    Returns:
  - isMap
```
public boolean isMap()
```
    Description copied from interface: TypeInformation
    
    Returns whether the property is a Map. If this returns true you can expect TypeInformation.getComponentType() as well as TypeInformation.getMapValueType() to return something not null.
    
    Specified by:
    
    isMap in interface TypeInformation<S>
    
    Returns:
  - getMapValueType
```
public TypeInformation<?> getMapValueType()
```
    Description copied from interface: TypeInformation
    
    Will return the type of the value in case the underlying type is a Map.
    
    Specified by:
    
    getMapValueType in interface TypeInformation<S>
    
    Returns:
  - doGetMapValueType
```
protected TypeInformation<?> doGetMapValueType()
```
  - isCollectionLike
```
public boolean isCollectionLike()
```
    Description copied from interface: TypeInformation
    
    Returns whether the type can be considered a collection, which means it's a container of elements, e.g. a Collection and Array or anything implementing Iterable. If this returns true you can expect TypeInformation.getComponentType() to return a non-null value.
    
    Specified by:
    
    isCollectionLike in interface TypeInformation<S>
    
    Returns:
  - getComponentType
```
public final TypeInformation<?> getComponentType()
```
    Description copied from interface: TypeInformation
    
    Returns the component type for Collections or the key type for Maps.
    
    Specified by:
    
    getComponentType in interface TypeInformation<S>
    
    Returns:
  - doGetComponentType
```
protected TypeInformation<?> doGetComponentType()
```
  - getReturnType
```
public TypeInformation<?> getReturnType(Method method)
```
    Description copied from interface: TypeInformation
    
    Returns a TypeInformation for the return type of the given Method. Will potentially resolve generics information against the current types type parameter bindings.
    
    Specified by:
    
    getReturnType in interface TypeInformation<S>
    
    Parameters:
    
    method - must not be null.
    
    Returns:
  - getParameterTypes
```
public List<TypeInformation<?>> getParameterTypes(Method method)
```
    Description copied from interface: TypeInformation
    
    Returns the TypeInformations for the parameters of the given Method.
    
    Specified by:
    
    getParameterTypes in interface TypeInformation<S>
    
    Parameters:
    
    method - must not be null.
    
    Returns:
  - getSuperTypeInformation
```
public TypeInformation<?> getSuperTypeInformation(Class<?> superType)
```
    Description copied from interface: TypeInformation
    
    Returns the TypeInformation for the given raw super type.
    
    Specified by:
    
    getSuperTypeInformation in interface TypeInformation<S>
    
    Parameters:
    
    superType - must not be null.
    
    Returns:
    
    the TypeInformation for the given raw super type or null in case the current TypeInformation does not implement the given type.
  - isAssignableFrom
```
public boolean isAssignableFrom(TypeInformation<?> target)
```
    Description copied from interface: TypeInformation
    
    Returns if the current TypeInformation can be safely assigned to the given one. Mimics semantics of Class.isAssignableFrom(Class) but takes generics into account. Thus it will allow to detect that a List<Long> is assignable to List<? extends Number>.
    
    Specified by:
    
    isAssignableFrom in interface TypeInformation<S>
    
    Returns:
  - getTypeArgument
```
public TypeInformation<?> getTypeArgument(Class<?> bound,
                                          int index)
```

Class TypeVariableTypeInformation<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TypeVariableTypeInformation

Method Detail

getType

getTypeArguments

equals

hashCode

toString

getVariableName

createInfo

getTypeVariableMap

resolveClass

resolveType

getParameterTypes

getGenericType

getRawTypeInformation

getActualType

isMap

getMapValueType

doGetMapValueType

isCollectionLike

getComponentType

doGetComponentType

getReturnType

getParameterTypes

getSuperTypeInformation

isAssignableFrom

getTypeArgument