Package de.gebit.integrity.parameter.resolving

## Interface ParameterResolver

- All Known Implementing Classes:
    `DefaultParameterResolver`

      public interface ParameterResolver

  The parameter resolver is responsible for the creation of a map of parameters for fixture executions. It does NOT convert any values, which is the duty of the `ValueConverter`.
  Author:
    Rene Schneider - initial API and implementation

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Map<String,​Object>` | `createExpectedResultMap​(Test aTest, boolean anIncludeArbitraryResultFlag)` | Returns a map of named results as expected by the given `Test`.
    `Map<String,​Object>` | `createParameterMap​(Call aCall, boolean anIncludeArbitraryParametersFlag, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Returns a map mapping a parameter name to a value, exploring a given `Call` to determine the valid parameters.
    `Map<String,​Object>` | `createParameterMap​(TableTest aTableTest, TableTestRow aTableTestRow, TableTestParameterResolveMethod aResolveMethod, boolean anIncludeArbitraryParametersFlag, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Returns a map mapping a parameter name to a value, exploring a given row of a `TableTest` to determine the valid parameters.
    `Map<String,​Object>` | `createParameterMap​(Test aTest, boolean anIncludeArbitraryParametersFlag, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Returns a map mapping a parameter name to a value, exploring a given `Test` to determine the valid parameters.
    `Map<String,​Object>` | `createParameterMap​(List<Parameter> someParameters, boolean anIncludeArbitraryParametersFlag, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Returns a map mapping a parameter name to a value, using a list of `Parameter` instances to determine the valid parameters.
    `boolean` | `isSafelyStaticallyResolvable​(ValueOrEnumValueOrOperationCollection aValue, VariantDefinition aVariant)` | Determines whether the given `ValueOrEnumValueOrOperationCollection` is safely resolvable to a value in a static way, that is, not requiring a current execution context.
    `boolean` | `isSafelyStaticallyResolvable​(ValueOrEnumValueOrOperation aValue, VariantDefinition aVariant)` | Determines whether the given `ValueOrEnumValueOrOperation` is safely resolvable to a value in a static way, that is, not requiring a current execution context.
    `Object` | `resolveParameterValue​(ValueOrEnumValueOrOperationCollection aValueCollection, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Resolves the given `ValueOrEnumValueOrOperationCollection`, using the variable map given.
    `Object` | `resolveSingleParameterValue​(ValueOrEnumValueOrOperation aValue, UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)` | Resolves the given `ValueOrEnumValueOrOperation`, using the variable map given.
    `Object` | `resolveStatically​(ConstantDefinition aConstant, VariantDefinition aVariant)` | Resolves a constant definition to its defined value, which may depend on the active variant.
    `Object` | `resolveStatically​(ValueOrEnumValueOrOperationCollection anEntity, VariantDefinition aVariant)` | Resolves a `ValueOrEnumValueOrOperationCollection` to its actual value statically, that is, not requiring a current test execution context.
    `Object` | `resolveStatically​(ValueOrEnumValueOrOperation anEntity, VariantDefinition aVariant)` | Resolves a `ValueOrEnumValueOrOperation` to its actual value statically, that is, not requiring a current test execution context.
    `Object` | `resolveStatically​(VariableOrConstantEntity anEntity, VariantDefinition aVariant)` | Resolves a variable (recursively, if necessary) to its actual value.
    `Object` | `resolveStatically​(Variable aVariable, VariantDefinition aVariant)` | Resolves a variable (recursively, if necessary) to its actual value.

- - ### Method Detail

    - #### createParameterMap

          Map<String,​Object> createParameterMap​(Test aTest,
                                                      boolean anIncludeArbitraryParametersFlag,
                                                      UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                               throws ClassNotFoundException,
                                                      UnexecutableException,
                                                      InstantiationException

      Returns a map mapping a parameter name to a value, exploring a given `Test` to determine the valid parameters. Parameters that contain references to variables will be resolved if the variable map is provided, but no type conversions will be done.
      Parameters:
        `aTest` - the test
        `anIncludeArbitraryParametersFlag` - whether arbitrary parameters should be determined and included as well
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        a map with a String to value mapping
      Throws:
        `InstantiationException`
        `UnexecutableException`
        `ClassNotFoundException`

    - #### createParameterMap

          Map<String,​Object> createParameterMap​(Call aCall,
                                                      boolean anIncludeArbitraryParametersFlag,
                                                      UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                               throws ClassNotFoundException,
                                                      UnexecutableException,
                                                      InstantiationException

      Returns a map mapping a parameter name to a value, exploring a given `Call` to determine the valid parameters. Parameters that contain references to variables will be resolved if the variable map is provided, but no type conversions will be done.
      Parameters:
        `aCall` - the call
        `anIncludeArbitraryParametersFlag` - whether arbitrary parameters should be determined and included as well
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        a map with a String to value mapping
      Throws:
        `InstantiationException`
        `UnexecutableException`
        `ClassNotFoundException`

    - #### createParameterMap

          Map<String,​Object> createParameterMap​(TableTest aTableTest,
                                                      TableTestRow aTableTestRow,
                                                      TableTestParameterResolveMethod aResolveMethod,
                                                      boolean anIncludeArbitraryParametersFlag,
                                                      UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                               throws ClassNotFoundException,
                                                      UnexecutableException,
                                                      InstantiationException

      Returns a map mapping a parameter name to a value, exploring a given row of a `TableTest` to determine the valid parameters. Parameters that contain operations and/or references to variables will be resolved if the variable map is provided, but no type conversions will be done.
      Parameters:
        `aTableTest` - the table test
        `aTableTestRow` - the row of the test
        `aResolveMethod` - specifies the kind of params to be resolved (null = `TableTestParameterResolveMethod.COMBINED`)
        `anIncludeArbitraryParametersFlag` - whether arbitrary parameters should be determined and included as well
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        a map with a String to value mapping
      Throws:
        `InstantiationException`
        `UnexecutableException`
        `ClassNotFoundException`

    - #### createParameterMap

          Map<String,​Object> createParameterMap​(List<Parameter> someParameters,
                                                      boolean anIncludeArbitraryParametersFlag,
                                                      UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                               throws ClassNotFoundException,
                                                      UnexecutableException,
                                                      InstantiationException

      Returns a map mapping a parameter name to a value, using a list of `Parameter` instances to determine the valid parameters. Parameters that contain operations or references to variables will be resolved if the variable map is provided, but no type conversions will be done.
      Parameters:
        `someParameters` - the parameters
        `anIncludeArbitraryParametersFlag` - whether arbitrary parameters should be determined and included as well
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        a map with a String to value mapping
      Throws:
        `InstantiationException`
        `UnexecutableException`
        `ClassNotFoundException`

    - #### resolveParameterValue

          Object resolveParameterValue​(ValueOrEnumValueOrOperationCollection aValueCollection,
                                       UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                throws UnexecutableException,
                                       InstantiationException,
                                       ClassNotFoundException

      Resolves the given `ValueOrEnumValueOrOperationCollection`, using the variable map given. Resolving only attempts to execute any operations and replace variable references with the current variable value, but does NOT convert the values to any other target type.
      Parameters:
        `aValueCollection` - the value collection to resolve
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        the resolved value
      Throws:
        `UnexecutableException`
        `InstantiationException`
        `ClassNotFoundException`

    - #### resolveSingleParameterValue

          Object resolveSingleParameterValue​(ValueOrEnumValueOrOperation aValue,
                                             UnresolvableVariableHandling anUnresolvableVariableHandlingPolicy)
                                      throws UnexecutableException,
                                             InstantiationException,
                                             ClassNotFoundException

      Resolves the given `ValueOrEnumValueOrOperation`, using the variable map given. Resolving only attempts to execute any operations and replace variable references with the current variable value, but does NOT convert the values to any other target type.
      Parameters:
        `aValue` - the value to resolve
        `anUnresolvableVariableHandlingPolicy` - Defines the policy how unresolvable variable references (no variable given or no `VariableManager` available) shall be treated
      Returns:
        the resolved value
      Throws:
        `UnexecutableException`
        `InstantiationException`
        `ClassNotFoundException`

    - #### resolveStatically

          Object resolveStatically​(Variable aVariable,
                                   VariantDefinition aVariant)
                            throws ClassNotFoundException,
                                   InstantiationException,
                                   UnexecutableException

      Resolves a variable (recursively, if necessary) to its actual value. Since this static method doesn't have access to the actual variable store of a test runner instance, the resolving can only be successful in cases of variables with initial value (giving that value) or constants.
      Parameters:
        `aVariable` - the variable to resolve
        `aVariant` - the active variant
      Returns:
        the result, or null if none was found
      Throws:
        `ClassNotFoundException`
        `InstantiationException`
        `UnexecutableException`

    - #### resolveStatically

          Object resolveStatically​(VariableOrConstantEntity anEntity,
                                   VariantDefinition aVariant)
                            throws ClassNotFoundException,
                                   InstantiationException,
                                   UnexecutableException

      Resolves a variable (recursively, if necessary) to its actual value. Since this static method doesn't have access to the actual variable store of a test runner instance, the resolving can only be successful in cases of variables with initial value (giving that value) or constants.
      Parameters:
        `anEntity` - the entity to resolve
        `aVariant` - the active variant
      Returns:
        the result, or null if none was found
      Throws:
        `ClassNotFoundException`
        `InstantiationException`
        `UnexecutableException`

    - #### resolveStatically

          Object resolveStatically​(ValueOrEnumValueOrOperation anEntity,
                                   VariantDefinition aVariant)
                            throws UnexecutableException,
                                   ClassNotFoundException,
                                   InstantiationException

      Resolves a `ValueOrEnumValueOrOperation` to its actual value statically, that is, not requiring a current test execution context.
      Parameters:
        `anEntity` - the entity to resolve
        `aVariant` - the variant in use
      Returns:
        the result value
      Throws:
        `UnexecutableException`
        `ClassNotFoundException`
        `InstantiationException`

    - #### resolveStatically

          Object resolveStatically​(ValueOrEnumValueOrOperationCollection anEntity,
                                   VariantDefinition aVariant)
                            throws UnexecutableException,
                                   ClassNotFoundException,
                                   InstantiationException

      Resolves a `ValueOrEnumValueOrOperationCollection` to its actual value statically, that is, not requiring a current test execution context.
      Parameters:
        `anEntity` - the entity to resolve
        `aVariant` - the variant in use
      Returns:
        the result value
      Throws:
        `UnexecutableException`
        `ClassNotFoundException`
        `InstantiationException`

    - #### isSafelyStaticallyResolvable

          boolean isSafelyStaticallyResolvable​(ValueOrEnumValueOrOperationCollection aValue,
                                               VariantDefinition aVariant)

      Determines whether the given `ValueOrEnumValueOrOperationCollection` is safely resolvable to a value in a static way, that is, not requiring a current execution context. "Safely" means that the resolved value is guaranteed not to change during runtime.
      Parameters:
        `aValue` - the value to test
        `aVariant` - the variant to assume
      Returns:
        true if the value is safely resolvable, false otherwise

    - #### isSafelyStaticallyResolvable

          boolean isSafelyStaticallyResolvable​(ValueOrEnumValueOrOperation aValue,
                                               VariantDefinition aVariant)

      Determines whether the given `ValueOrEnumValueOrOperation` is safely resolvable to a value in a static way, that is, not requiring a current execution context. "Safely" means that the resolved value is guaranteed not to change during runtime.
      Parameters:
        `aValue` - the value to test
        `aVariant` - the variant to assume
      Returns:
        true if the value is safely resolvable, false otherwise

    - #### resolveStatically

          Object resolveStatically​(ConstantDefinition aConstant,
                                   VariantDefinition aVariant)
                            throws UnexecutableException,
                                   ClassNotFoundException,
                                   InstantiationException

      Resolves a constant definition to its defined value, which may depend on the active variant.
      Parameters:
        `aConstant` - the constant to resolve
        `aVariant` - the active variant
      Returns:
        the result, or null if none is defined for the constant
      Throws:
        `UnexecutableException`
        `ClassNotFoundException`
        `InstantiationException`

    - #### createExpectedResultMap

          Map<String,​Object> createExpectedResultMap​(Test aTest,
                                                           boolean anIncludeArbitraryResultFlag)

      Returns a map of named results as expected by the given `Test`. The Map will connect result names to actual values. Does not support variable resolving!
      Parameters:
        `aTest` - the test
        `anIncludeArbitraryResultFlag` - whether arbitrary results shall be included
      Returns:
        a map of Strings to values