org.optaplanner.core.api.score.buildin.bendablebigdecimal

## Class BendableBigDecimalScoreHolder

- java.lang.Object
- - org.optaplanner.core.api.score.holder.AbstractScoreHolder<BendableBigDecimalScore>
  - - org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScoreHolder

- All Implemented Interfaces:
    Serializable, ScoreHolder<BendableBigDecimalScore>

      public class BendableBigDecimalScoreHolder
      extends AbstractScoreHolder<BendableBigDecimalScore>

  See Also:
    `BendableBigDecimalScore`, Serialized Form

- - ### Nested Class Summary

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

      `AbstractScoreHolder.ConstraintActivationUnMatchListener`

  - ### Field Summary

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

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

      `constraintMatchEnabled, constraintMatchTotalMap, indictmentMap, zeroScore`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BendableBigDecimalScoreHolder(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addHardConstraintMatch(org.kie.api.runtime.rule.RuleContext kcontext, int hardLevel, BigDecimal weight)`
    `void` | `addMultiConstraintMatch(org.kie.api.runtime.rule.RuleContext kcontext, BigDecimal[] hardWeights, BigDecimal[] softWeights)`
    `void` | `addSoftConstraintMatch(org.kie.api.runtime.rule.RuleContext kcontext, int softLevel, BigDecimal weight)`
    `void` | `configureConstraintWeight(org.kie.api.definition.rule.Rule rule, BendableBigDecimalScore constraintWeight)` Sets up a `ConstraintWeight` from the `ConstraintConfiguration` during initialization.
    `BendableBigDecimalScore` | `extractScore(int initScore)` Extracts the `Score`, calculated by the `KieSession` for `DroolsScoreDirector`.
    `int` | `getHardLevelsSize()`
    `BigDecimal` | `getHardScore(int hardLevel)`
    `int` | `getSoftLevelsSize()`
    `BigDecimal` | `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, 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, BigDecimal 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, BigDecimal[] hardWeightsMultiplier, BigDecimal[] 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, BigDecimal weightMultiplier)` Reward a match by the `ConstraintWeight` multiplied with the weightMultiplier for all score levels.
    `void` | `reward(org.kie.api.runtime.rule.RuleContext kcontext, BigDecimal[] hardWeightsMultiplier, BigDecimal[] softWeightsMultiplier)` Reward a match by the `ConstraintWeight` multiplied with the specific weightMultiplier per score level.

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

      `extractJustificationList, getConstraintMatchTotalMap, getConstraintMatchTotals, getIndictmentMap, impactScore, impactScore, isConstraintMatchEnabled, registerConstraintMatch`

    - ### 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,BigDecimal>> matchExecutorByNumberMap

    - #### matchExecutorByScoreMap

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

      Slower than `matchExecutorByNumberMap`

  - ### Constructor Detail

    - #### BendableBigDecimalScoreHolder

          public BendableBigDecimalScoreHolder(boolean constraintMatchEnabled,
                                               int hardLevelsSize,
                                               int softLevelsSize)

  - ### Method Detail

    - #### getHardLevelsSize

          public int getHardLevelsSize()

    - #### getHardScore

          public BigDecimal getHardScore(int hardLevel)

    - #### getSoftLevelsSize

          public int getSoftLevelsSize()

    - #### getSoftScore

          public BigDecimal getSoftScore(int softLevel)

    - #### configureConstraintWeight

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

      Description copied from interface: `ScoreHolder`
      Sets up a `ConstraintWeight` from the `ConstraintConfiguration` during initialization.
      Specified by:
        `configureConstraintWeight` in interface `ScoreHolder<BendableBigDecimalScore>`
      Overrides:
        `configureConstraintWeight` in class `AbstractScoreHolder<BendableBigDecimalScore>`
      Parameters:
        `rule` - never null
        `constraintWeight` - never null, with `Score.getInitScore()` equal to 0.

    - #### penalize

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

      Penalize a match by the `ConstraintWeight` negated.
      Parameters:
        `kcontext` - never null, the magic variable in DRL

    - #### penalize

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

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

    - #### penalize

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

      Penalize a match by the `ConstraintWeight` negated and multiplied with the specific weightMultiplier per score level. Slower than `penalize(RuleContext, BigDecimal)`.
      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)

      Reward a match by the `ConstraintWeight`.
      Parameters:
        `kcontext` - never null, the magic variable in DRL

    - #### reward

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

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

    - #### reward

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

      Reward a match by the `ConstraintWeight` multiplied with the specific weightMultiplier per score level. Slower than `reward(RuleContext, BigDecimal)`.
      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<BendableBigDecimalScore>`
      Parameters:
        `kcontext` - never null

    - #### 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.
      Overrides:
        `impactScore` in class `AbstractScoreHolder<BendableBigDecimalScore>`
      Parameters:
        `kcontext` - never null
        `weightMultiplier` - any

    - #### addHardConstraintMatch

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

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

    - #### addSoftConstraintMatch

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

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

    - #### addMultiConstraintMatch

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

      Parameters:
        `kcontext` - never null, the magic variable in DRL
        `hardWeights` - never null, array of length `getHardLevelsSize()`, does not contain any nulls
        `softWeights` - never null, array of length `getSoftLevelsSize()`, does not contain any nulls

    - #### extractScore

          public BendableBigDecimalScore extractScore(int initScore)

      Description copied from interface: `ScoreHolder`
      Extracts the `Score`, calculated by the `KieSession` for `DroolsScoreDirector`.

      Should not be called directly, use `ScoreDirector.calculateScore()` instead.

      Parameters:
        `initScore` - `<= 0`, managed by OptaPlanner, needed as a parameter in the `Score`'s creation method, see `Score.getInitScore()`
      Returns:
        never null, the `Score` of the working `PlanningSolution`

Copyright © 2006–2019 JBoss by Red Hat. All rights reserved.