Package org.optaplanner.core.impl.score.buildin.bendable

## Class BendableScoreHolderImpl

- java.lang.Object
- - org.optaplanner.core.impl.score.holder.AbstractScoreHolder<BendableScore>
  - - org.optaplanner.core.impl.score.buildin.bendable.BendableScoreHolderImpl

- All Implemented Interfaces:
    `BendableScoreHolder`, `ScoreHolder<BendableScore>`

      public final class BendableScoreHolderImpl
      extends AbstractScoreHolder<BendableScore>
      implements BendableScoreHolder

  See Also:
    `BendableScore`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.optaplanner.core.impl.score.holder.AbstractScoreHolder

      `AbstractScoreHolder.ConstraintActivationUnMatchListener`

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected Map<org.kie.api.definition.rule.Rule,​BiConsumer<org.kie.api.runtime.rule.RuleContext,​Integer>>` | `matchExecutorByNumberMap` |
    `protected Map<org.kie.api.definition.rule.Rule,​BiConsumer<org.kie.api.runtime.rule.RuleContext,​BendableScore>>` | `matchExecutorByScoreMap` | Slower than `matchExecutorByNumberMap`

    - ### Fields inherited from class org.optaplanner.core.impl.score.holder.AbstractScoreHolder

      `constraintMatchEnabled, constraintMatchTotalMap, indictmentMap, zeroScore`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `BendableScoreHolderImpl​(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addHardConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext, int hardLevel, int weight)` |
    `void` | `addMultiConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext, int[] hardWeights, int[] softWeights)` |
    `void` | `addSoftConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext, int softLevel, int weight)` |
    `void` | `configureConstraintWeight​(org.kie.api.definition.rule.Rule rule, BendableScore constraintWeight)` |
    `BendableScore` | `extractScore​(int initScore)` |
    `int` | `getHardLevelsSize()` |
    `int` | `getHardScore​(int hardLevel)` |
    `int` | `getSoftLevelsSize()` |
    `int` | `getSoftScore​(int softLevel)` |
    `void` | `impactScore​(org.kie.api.runtime.rule.RuleContext kcontext)` | For internal use only, use penalize() or reward() instead.
    `void` | `impactScore​(org.kie.api.runtime.rule.RuleContext kcontext, int weightMultiplier)` | For internal use only, use penalize() or reward() instead.
    `void` | `impactScore​(org.kie.api.runtime.rule.RuleContext kcontext, long weightMultiplier)` | For internal use only, use penalize() or reward() instead.
    `void` | `impactScore​(org.kie.api.runtime.rule.RuleContext kcontext, BigDecimal weightMultiplier)` | For internal use only, use penalize() or reward() instead.
    `void` | `penalize​(org.kie.api.runtime.rule.RuleContext kcontext)` | Penalize a match by the `ConstraintWeight` negated.
    `void` | `penalize​(org.kie.api.runtime.rule.RuleContext kcontext, int weightMultiplier)` | Penalize a match by the `ConstraintWeight` negated and multiplied with the weightMultiplier for all score levels.
    `void` | `penalize​(org.kie.api.runtime.rule.RuleContext kcontext, int[] hardWeightsMultiplier, int[] softWeightsMultiplier)` | Penalize a match by the `ConstraintWeight` negated and multiplied with the specific weightMultiplier per score level.
    `void` | `reward​(org.kie.api.runtime.rule.RuleContext kcontext)` | Reward a match by the `ConstraintWeight`.
    `void` | `reward​(org.kie.api.runtime.rule.RuleContext kcontext, int weightMultiplier)` | Reward a match by the `ConstraintWeight` multiplied with the weightMultiplier for all score levels.
    `void` | `reward​(org.kie.api.runtime.rule.RuleContext kcontext, int[] hardWeightsMultiplier, int[] softWeightsMultiplier)` | Reward a match by the `ConstraintWeight` multiplied with the specific weightMultiplier per score level.

    - ### Methods inherited from class org.optaplanner.core.impl.score.holder.AbstractScoreHolder

      `extractJustificationList, getConstraintMatchTotalMap, getIndictmentMap, isConstraintMatchEnabled, registerConstraintMatch, setJustificationListConverter`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### matchExecutorByNumberMap

          protected final Map<org.kie.api.definition.rule.Rule,​BiConsumer<org.kie.api.runtime.rule.RuleContext,​Integer>> matchExecutorByNumberMap

    - #### matchExecutorByScoreMap

          protected final Map<org.kie.api.definition.rule.Rule,​BiConsumer<org.kie.api.runtime.rule.RuleContext,​BendableScore>> matchExecutorByScoreMap

      Slower than `matchExecutorByNumberMap`

  - ### Constructor Detail

    - #### BendableScoreHolderImpl

          public BendableScoreHolderImpl​(boolean constraintMatchEnabled,
                                         int hardLevelsSize,
                                         int softLevelsSize)

  - ### Method Detail

    - #### getHardLevelsSize

          public int getHardLevelsSize()

      Specified by:
        `getHardLevelsSize` in interface `BendableScoreHolder`

    - #### getHardScore

          public int getHardScore​(int hardLevel)

    - #### getSoftLevelsSize

          public int getSoftLevelsSize()

      Specified by:
        `getSoftLevelsSize` in interface `BendableScoreHolder`

    - #### getSoftScore

          public int getSoftScore​(int softLevel)

    - #### configureConstraintWeight

          public void configureConstraintWeight​(org.kie.api.definition.rule.Rule rule,
                                                BendableScore constraintWeight)

      Overrides:
        `configureConstraintWeight` in class `AbstractScoreHolder<BendableScore>`

    - #### penalize

          public void penalize​(org.kie.api.runtime.rule.RuleContext kcontext)

      Description copied from interface: `ScoreHolder`
      Penalize a match by the `ConstraintWeight` negated.
      Specified by:
        `penalize` in interface `ScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null, the magic variable in DRL

    - #### penalize

          public void penalize​(org.kie.api.runtime.rule.RuleContext kcontext,
                               int weightMultiplier)

      Description copied from interface: `BendableScoreHolder`
      Penalize a match by the `ConstraintWeight` negated and multiplied with the weightMultiplier for all score levels.
      Specified by:
        `penalize` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `weightMultiplier` - at least 0

    - #### penalize

          public void penalize​(org.kie.api.runtime.rule.RuleContext kcontext,
                               int[] hardWeightsMultiplier,
                               int[] softWeightsMultiplier)

      Description copied from interface: `BendableScoreHolder`
      Penalize a match by the `ConstraintWeight` negated and multiplied with the specific weightMultiplier per score level. Slower than `BendableScoreHolder.penalize(RuleContext, int)`.
      Specified by:
        `penalize` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `hardWeightsMultiplier` - elements at least 0
        `softWeightsMultiplier` - elements at least 0

    - #### reward

          public void reward​(org.kie.api.runtime.rule.RuleContext kcontext)

      Description copied from interface: `ScoreHolder`
      Reward a match by the `ConstraintWeight`.
      Specified by:
        `reward` in interface `ScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null, the magic variable in DRL

    - #### reward

          public void reward​(org.kie.api.runtime.rule.RuleContext kcontext,
                             int weightMultiplier)

      Description copied from interface: `BendableScoreHolder`
      Reward a match by the `ConstraintWeight` multiplied with the weightMultiplier for all score levels.
      Specified by:
        `reward` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `weightMultiplier` - at least 0

    - #### reward

          public void reward​(org.kie.api.runtime.rule.RuleContext kcontext,
                             int[] hardWeightsMultiplier,
                             int[] softWeightsMultiplier)

      Description copied from interface: `BendableScoreHolder`
      Reward a match by the `ConstraintWeight` multiplied with the specific weightMultiplier per score level. Slower than `BendableScoreHolder.reward(RuleContext, int)`.
      Specified by:
        `reward` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `hardWeightsMultiplier` - elements at least 0
        `softWeightsMultiplier` - elements at least 0

    - #### impactScore

          public void impactScore​(org.kie.api.runtime.rule.RuleContext kcontext)

      Description copied from class: `AbstractScoreHolder`
      For internal use only, use penalize() or reward() instead.
      Overrides:
        `impactScore` in class `AbstractScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null

    - #### impactScore

          public void impactScore​(org.kie.api.runtime.rule.RuleContext kcontext,
                                  int weightMultiplier)

      Description copied from class: `AbstractScoreHolder`
      For internal use only, use penalize() or reward() instead.
      Specified by:
        `impactScore` in interface `BendableScoreHolder`
      Specified by:
        `impactScore` in class `AbstractScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null
        `weightMultiplier` - any

    - #### impactScore

          public void impactScore​(org.kie.api.runtime.rule.RuleContext kcontext,
                                  long weightMultiplier)

      Description copied from class: `AbstractScoreHolder`
      For internal use only, use penalize() or reward() instead.
      Specified by:
        `impactScore` in class `AbstractScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null
        `weightMultiplier` - any

    - #### impactScore

          public void impactScore​(org.kie.api.runtime.rule.RuleContext kcontext,
                                  BigDecimal weightMultiplier)

      Description copied from class: `AbstractScoreHolder`
      For internal use only, use penalize() or reward() instead.
      Specified by:
        `impactScore` in class `AbstractScoreHolder<BendableScore>`
      Parameters:
        `kcontext` - never null
        `weightMultiplier` - any

    - #### addHardConstraintMatch

          public void addHardConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext,
                                             int hardLevel,
                                             int weight)

      Specified by:
        `addHardConstraintMatch` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `hardLevel` - `0 <= hardLevel <` `BendableScoreHolder.getHardLevelsSize()`. The `scoreLevel` is `hardLevel` for hard levels and `softLevel + hardLevelSize` for soft levels.
        `weight` - higher is better, negative for a penalty, positive for a reward

    - #### addSoftConstraintMatch

          public void addSoftConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext,
                                             int softLevel,
                                             int weight)

      Specified by:
        `addSoftConstraintMatch` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `softLevel` - `0 <= softLevel <` `BendableScoreHolder.getSoftLevelsSize()`. The `scoreLevel` is `hardLevel` for hard levels and `softLevel + hardLevelSize` for soft levels.
        `weight` - higher is better, negative for a penalty, positive for a reward

    - #### addMultiConstraintMatch

          public void addMultiConstraintMatch​(org.kie.api.runtime.rule.RuleContext kcontext,
                                              int[] hardWeights,
                                              int[] softWeights)

      Specified by:
        `addMultiConstraintMatch` in interface `BendableScoreHolder`
      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `hardWeights` - never null, array of length `BendableScoreHolder.getHardLevelsSize()`
        `softWeights` - never null, array of length `BendableScoreHolder.getSoftLevelsSize()`

    - #### extractScore

          public BendableScore extractScore​(int initScore)

      Specified by:
        `extractScore` in class `AbstractScoreHolder<BendableScore>`