AbstractParameterInfo (Spoon Core 8.2.0-SNAPSHOT API)

java.lang.Object
- spoon.pattern.internal.parameter.AbstractParameterInfo

All Implemented Interfaces:

ParameterInfo

Direct Known Subclasses:

ComputedParameterInfo, ListParameterInfo, MapParameterInfo, SetParameterInfo
```
public abstract class AbstractParameterInfo
extends Object
implements ParameterInfo
```

Field Summary

Fields
Modifier and Type Field and Description

protected static Object NO_MERGE
is used as return value when value cannot be added
- Fields inherited from interface spoon.pattern.internal.parameter.ParameterInfo
  UNLIMITED_OCCURRENCES

Fields
Modifier and Type	Field and Description
`protected static Object`	`NO_MERGE` is used as return value when value cannot be added

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractParameterInfo(ParameterInfo containerItemAccessor)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractParameterInfo(ParameterInfo containerItemAccessor)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`ImmutableMap`	`addValueAs(ImmutableMap parameters, Object value)` Matches `value` into `parameters` under the name/structure defined by this ParameterInfo.
`protected abstract Object`	`addValueAs(Object container, Function<Object,Object> merger)` takes existing item value from the `container`, sends it as parameter into `merger` and get's new to be stored value stores that value into new `container` and returns it
`protected Object`	`addValueToContainer(Object container, Function<Object,Object> merger)`
`protected <T> T`	`castTo(Object o, Class<T> type)`
`protected <T> T`	`convertSingleValue(Factory factory, Object value, Class<T> type)`
`protected <T> void`	`convertValue(Factory factory, ResultHolder<T> result, Object rawValue)`
`ContainerKind`	`getContainerKind()`
`protected ContainerKind`	`getContainerKind(ImmutableMap params)`
`protected ContainerKind`	`getContainerKind(Object existingValue, Object value)`
`protected AbstractParameterInfo`	`getContainerKindAccessor(ContainerKind containerKind)`
`protected String`	`getContainerName()`
`protected abstract <T> T`	`getEmptyContainer()`
`Quantifier`	`getMatchingStrategy()`
`int`	`getMaxOccurrences()`
`int`	`getMinOccurrences()`
`String`	`getName()`
`Class<?>`	`getParameterValueType()`
`protected abstract String`	`getPlainName()`
`protected Object`	`getValue(ImmutableMap parameters)`
`<T> void`	`getValueAs(Factory factory, ResultHolder<T> result, ImmutableMap parameters)` Takes the value of parameter identified by this `ParameterInfo` from the `parameters` and adds that 0, 1 or more values into result (depending on type of result)
`ValueConvertor`	`getValueConvertor()`
`protected abstract String`	`getWrappedName(String containerName)`
`boolean`	`isMandatory(ImmutableMap parameters)`
`boolean`	`isMultiple()`
`boolean`	`isRepeatable()`
`boolean`	`isTryNextMatch(ImmutableMap parameters)`
`protected boolean`	`matches(Object value)` Checks whether `value` matches with required type and match condition.
`protected Object`	`merge(Object existingValue, Object newValue)`
`protected Object`	`mergeSingle(Object existingValue, Object newValue)`
`AbstractParameterInfo`	`setContainerKind(ContainerKind containerKind)`
`<T> AbstractParameterInfo`	`setMatchCondition(Class<T> requiredType, Predicate<T> matchCondition)`
`void`	`setMatchingStrategy(Quantifier matchingStrategy)`
`void`	`setMaxOccurrences(int maxOccurrences)`
`AbstractParameterInfo`	`setMinOccurrences(int minOccurrences)`
`AbstractParameterInfo`	`setParameterValueType(Class<?> parameterValueType)`
`AbstractParameterInfo`	`setRepeatable(boolean repeatable)`
`AbstractParameterInfo`	`setValueConvertor(ValueConvertor valueConvertor)`
`String`	`toString()`

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

- Field Detail
  - NO_MERGE
```
protected static final Object NO_MERGE
```
    is used as return value when value cannot be added
- Constructor Detail
  - AbstractParameterInfo
```
protected AbstractParameterInfo(ParameterInfo containerItemAccessor)
```
- Method Detail
  - getContainerName
```
protected String getContainerName()
```
  - getName
```
public final String getName()
```
    Specified by:
    
    getName in interface ParameterInfo
    
    Returns:
    
    the full name of the parameter from the root of parameter container to the value represented by this ParameterInfo
  - getPlainName
```
protected abstract String getPlainName()
```
  - getWrappedName
```
protected abstract String getWrappedName(String containerName)
```
  - addValueAs
```
public ImmutableMap addValueAs(ImmutableMap parameters,
                               Object value)
```
    Description copied from interface: ParameterInfo
    
    Matches `value` into `parameters` under the name/structure defined by this ParameterInfo. 1) checks that value matches with optional internal rules of this ParameterInfo 2) creates new copy of ImmutableMap which contains the new `value` and returns that copy
    
    Specified by:
    
    addValueAs in interface ParameterInfo
    
    Parameters:
    
    parameters - the existing parameters
    
    value - the new, to be stored value
    
    Returns:
    
    copy of `parameters` with new value or existing `parameters` if value is already there or null if value doesn't fit into these parameters
  - addValueToContainer
```
protected Object addValueToContainer(Object container,
                                     Function<Object,Object> merger)
```
  - merge
```
protected Object merge(Object existingValue,
                       Object newValue)
```
  - getContainerKindAccessor
```
protected AbstractParameterInfo getContainerKindAccessor(ContainerKind containerKind)
```
  - mergeSingle
```
protected Object mergeSingle(Object existingValue,
                             Object newValue)
```
  - addValueAs
```
protected abstract Object addValueAs(Object container,
                                     Function<Object,Object> merger)
```
    takes existing item value from the `container`, sends it as parameter into `merger` and get's new to be stored value stores that value into new `container` and returns it
    
    Parameters:
    
    container - a container of values
    
    merger - a code which merges existing value from container with new value and returns merged value, which has to be stored in the container instead
    
    Returns:
    
    copy of the container with merged value
  - castTo
```
protected <T> T castTo(Object o,
                       Class<T> type)
```
  - getEmptyContainer
```
protected abstract <T> T getEmptyContainer()
```
  - setMatchCondition
```
public <T> AbstractParameterInfo setMatchCondition(Class<T> requiredType,
                                                   Predicate<T> matchCondition)
```
    Parameters:
    
    requiredType - a required type of the value which matches as value of this parameter
    
    matchCondition - a Predicate which selects matching values
    
    Returns:
  - matches
```
protected boolean matches(Object value)
```
    Checks whether `value` matches with required type and match condition.
    
    Parameters:
    
    value -
    
    Returns:
  - getParameterValueType
```
public Class<?> getParameterValueType()
```
    Specified by:
    
    getParameterValueType in interface ParameterInfo
    
    Returns:
    
    a type of parameter value - if known Note: Pattern builder needs to know the value type to be able to select substitute node. For example patter: return _expression_.S(); either replaces only `_expression_.S()` if the parameter value is an expression or replaces `return _expression_.S()` if the parameter value is a CtBlock
  - setParameterValueType
```
public AbstractParameterInfo setParameterValueType(Class<?> parameterValueType)
```
    Parameters:
    
    parameterValueType - a type of the value which is acceptable by this parameter
    
    Returns:
    
    this to support fluent API
  - isMultiple
```
public boolean isMultiple()
```
    Specified by:
    
    isMultiple in interface ParameterInfo
    
    Returns:
    
    true if the value container has to be a List, otherwise the container will be a single value
  - setRepeatable
```
public AbstractParameterInfo setRepeatable(boolean repeatable)
```
    Parameters:
    
    repeatable - if this matcher can be applied more than once in the same container of targets Note: even if false, it may be applied again to another container and to match EQUAL value.
    
    Returns:
    
    this to support fluent API
  - getMinOccurrences
```
public int getMinOccurrences()
```
  - setMinOccurrences
```
public AbstractParameterInfo setMinOccurrences(int minOccurrences)
```
  - getMaxOccurrences
```
public int getMaxOccurrences()
```
    Returns:
    
    maximum number of values in this parameter. Note: if isMultiple()==false, then it never returns value > 1
  - setMaxOccurrences
```
public void setMaxOccurrences(int maxOccurrences)
```
  - getMatchingStrategy
```
public Quantifier getMatchingStrategy()
```
    Specified by:
    
    getMatchingStrategy in interface ParameterInfo
    
    Returns:
    
    the strategy used to resolve conflict between two RootNodes
  - setMatchingStrategy
```
public void setMatchingStrategy(Quantifier matchingStrategy)
```
  - getValueConvertor
```
public ValueConvertor getValueConvertor()
```
    Returns:
    
    the ValueConvertor used by reading and writing into parameter values defined by this ParameterInfo
  - setValueConvertor
```
public AbstractParameterInfo setValueConvertor(ValueConvertor valueConvertor)
```
    Parameters:
    
    valueConvertor - the ValueConvertor used by reading and writing into parameter values defined by this ParameterInfo
  - isRepeatable
```
public boolean isRepeatable()
```
    Specified by:
    
    isRepeatable in interface ParameterInfo
    
    Returns:
    
    true if this matcher can be applied more than once in the same container of targets Note: even if false, it may be applied again to another container and to match EQUAL value
  - isMandatory
```
public boolean isMandatory(ImmutableMap parameters)
```
    Specified by:
    
    isMandatory in interface ParameterInfo
    
    Parameters:
    
    parameters - matching parameters
    
    Returns:
    
    true if the ValueResolver of this parameter MUST match with next target in the state defined by current `parameters`. false if match is optional
  - isTryNextMatch
```
public boolean isTryNextMatch(ImmutableMap parameters)
```
    Specified by:
    
    isTryNextMatch in interface ParameterInfo
    
    Parameters:
    
    parameters - matching parameters
    
    Returns:
    
    true if the ValueResolver of this parameter should be processed again to match next target in the state defined by current `parameters`.
  - getContainerKind
```
public ContainerKind getContainerKind()
```
  - setContainerKind
```
public AbstractParameterInfo setContainerKind(ContainerKind containerKind)
```
  - getContainerKind
```
protected ContainerKind getContainerKind(ImmutableMap params)
```
  - getContainerKind
```
protected ContainerKind getContainerKind(Object existingValue,
                                         Object value)
```
  - getValueAs
```
public <T> void getValueAs(Factory factory,
                           ResultHolder<T> result,
                           ImmutableMap parameters)
```
    Description copied from interface: ParameterInfo
    
    Takes the value of parameter identified by this ParameterInfo from the `parameters` and adds that 0, 1 or more values into result (depending on type of result)
    
    Specified by:
    
    getValueAs in interface ParameterInfo
    
    Parameters:
    
    factory - the factory used to create new entities if conversion of value is needed before it can be added into `result`
    
    result - the receiver of the result value. It defined required type of returned value and multiplicity of returned value
    
    parameters - here are stored all the parameter values
  - getValue
```
protected Object getValue(ImmutableMap parameters)
```
  - convertValue
```
protected <T> void convertValue(Factory factory,
                                ResultHolder<T> result,
                                Object rawValue)
```
  - convertSingleValue
```
protected <T> T convertSingleValue(Factory factory,
                                   Object value,
                                   Class<T> type)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AbstractParameterInfo

Field Summary

Fields inherited from interface spoon.pattern.internal.parameter.ParameterInfo

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NO_MERGE

Constructor Detail

AbstractParameterInfo

Method Detail

getContainerName

getName

getPlainName

getWrappedName

addValueAs

addValueToContainer

merge

getContainerKindAccessor

mergeSingle

addValueAs

castTo

getEmptyContainer

setMatchCondition

matches

getParameterValueType

setParameterValueType

isMultiple

setRepeatable

getMinOccurrences

setMinOccurrences

getMaxOccurrences

setMaxOccurrences

getMatchingStrategy

setMatchingStrategy

getValueConvertor

setValueConvertor

isRepeatable

isMandatory

isTryNextMatch

getContainerKind

setContainerKind

getContainerKind

getContainerKind

getValueAs

getValue

convertValue

convertSingleValue

toString