randoop.types

Class Substitution

java.lang.Object

randoop.types.Substitution

public class Substitution
extends java.lang.Object

A substitution maps type parameters/variables (including wildcards) to concrete types. It represents the instantiation of a generic class to a parameterized type.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.Map<TypeVariable,ReferenceType>	map The map from type variables to concrete types.
private java.util.Map<java.lang.reflect.Type,ReferenceType>	rawMap Map on reflection types - used for testing bounds.
private static java.util.function.BiFunction<ReferenceType,ReferenceType,ReferenceType>	requireSameEntry Throws an exception if its arguments are different non-null values.

Constructor Summary

Constructors

Constructor and Description
Substitution() Create an empty substitution.
Substitution(java.util.List<TypeVariable> parameters, java.util.List<ReferenceType> arguments) Create a substitution from the type parameters to the corresponding type arguments.
Substitution(java.util.List<TypeVariable> parameters, ReferenceType... arguments) Create a substitution from the type parameters to the corresponding type arguments.
Substitution(Substitution substitution) Make a copy of the given substitution.
Substitution(TypeVariable parameter, ReferenceType argument) Create a substitution that maps the given type parameter to the given type argument.

Method Summary

Modifier and Type	Method and Description
boolean	equals(@Nullable java.lang.Object obj)
Substitution	extend(java.util.List<TypeVariable> parameters, java.util.List<ReferenceType> arguments) Creates a new substitution that contains the mappings of this substitution, extended by the given mappings.
Substitution	extend(Substitution other) Creates a new substitution that contains the entries of two substitutions.
@Nullable ReferenceType	get(java.lang.reflect.Type parameter) Returns the value for the given Type
@Nullable ReferenceType	get(TypeVariable parameter) Returns the concrete type mapped from the type variable by this substitution.
ReferenceType	getOrDefault(TypeVariable parameter, ReferenceType defaultValue) Returns the concrete type mapped from the type variable by this substitution.
int	hashCode()
boolean	isConsistentWith(Substitution substitution) Two substitutions are consistent if their type variables are disjoint or, if they both map the same type variable, they map it to the same type.
boolean	isEmpty() Indicates whether this substitution is empty.
java.util.Set<TypeVariable>	keySet() Returns the type variables mapped from by this.
void	print() Print the entries of this substitution to standard out on multiple lines.
private void	put(TypeVariable typeParameter, ReferenceType type) Add a type variable to concrete type mapping to the substitution.
java.lang.String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

map

private java.util.Map<TypeVariable,ReferenceType> map

The map from type variables to concrete types.

rawMap

private java.util.Map<java.lang.reflect.Type,ReferenceType> rawMap

Map on reflection types - used for testing bounds. Its keys are a subset of the keys of map: those that are type parameters as opposed to other type variables such as wildcards.

requireSameEntry

private static java.util.function.BiFunction<ReferenceType,ReferenceType,ReferenceType> requireSameEntry

Throws an exception if its arguments are different non-null values.

Constructor Detail

Substitution

public Substitution()

Create an empty substitution.

Substitution

public Substitution(Substitution substitution)

Make a copy of the given substitution.

Parameters:

substitution - the substitution to copy

Substitution

public Substitution(TypeVariable parameter,
                    ReferenceType argument)

Create a substitution that maps the given type parameter to the given type argument.

Parameters:

parameter - the type parameter

argument - the type argument

Substitution

public Substitution(java.util.List<TypeVariable> parameters,
                    ReferenceType... arguments)

Create a substitution from the type parameters to the corresponding type arguments.

Parameters:

parameters - the type parameters

arguments - the type arguments

Substitution

public Substitution(java.util.List<TypeVariable> parameters,
                    java.util.List<ReferenceType> arguments)

Create a substitution from the type parameters to the corresponding type arguments.

Parameters:

parameters - the type parameters

arguments - the type arguments

Method Detail

equals

public boolean equals(@Nullable java.lang.Object obj)

Overrides:

equals in class java.lang.Object

Returns:

true if the substitution maps are identical and false otherwise

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

isConsistentWith

public boolean isConsistentWith(Substitution substitution)

Two substitutions are consistent if their type variables are disjoint or, if they both map the same type variable, they map it to the same type. This is the test for whether this substitution can be extended by the other substitution using extend(Substitution).

Parameters:

substitution - the other substitution to check for consistency with this substitution

Returns:

true if the substitutions are consistent, false otherwise

extend

public Substitution extend(java.util.List<TypeVariable> parameters,
                           java.util.List<ReferenceType> arguments)

Creates a new substitution that contains the mappings of this substitution, extended by the given mappings. If this and the additional mappings contain the same type variable, both must map it to the same type.

Parameters:

parameters - the type parameters

arguments - the type arguments

Returns:

a new substitution that is this substitution extended by the given mappings

extend

public Substitution extend(Substitution other)

Creates a new substitution that contains the entries of two substitutions. If both substitutions contain the same type variable, they must map to the same type.

Parameters:

other - the substitution to add to this substitution

Returns:

a new substitution that is this substitution extended by the given substitution

get

public @Nullable ReferenceType get(TypeVariable parameter)

Returns the concrete type mapped from the type variable by this substitution. Returns null if the variable is not in the substitution.

Parameters:

parameter - the variable

Returns:

the concrete type mapped from the variable in this substitution, or null if there is no type for the variable

getOrDefault

public ReferenceType getOrDefault(TypeVariable parameter,
                                  ReferenceType defaultValue)

Returns the concrete type mapped from the type variable by this substitution. Returns the given default value if the variable is not in the substitution.

Parameters:

parameter - the variable

defaultValue - the default value to return if the variable is not in the substitution

Returns:

the concrete type mapped from the variable in this substitution, or default if there is no type for the variable

get

public @Nullable ReferenceType get(java.lang.reflect.Type parameter)

Returns the value for the given Type

Parameters:

parameter - the type variable

Returns:

the value for the type variable, or null if there is none

keySet

public java.util.Set<TypeVariable> keySet()

Returns the type variables mapped from by this.

Returns:

the type variables mapped from by this

print

public void print()

Print the entries of this substitution to standard out on multiple lines.

put

private void put(@UnknownInitialization Substitution this,
                 TypeVariable typeParameter,
                 ReferenceType type)

Add a type variable to concrete type mapping to the substitution.

Parameters:

typeParameter - the type variable

type - the concrete type

isEmpty

public boolean isEmpty()

Indicates whether this substitution is empty.

Returns:

true if this has no substitution pairs, false otherwise