org.optaplanner.core.api.score.stream.bi

## Interface BiConstraintStream<A,B>

- Type Parameters:
    `A` - the type of the first fact in the tuple.
    `B` - the type of the second fact in the tuple.
  All Superinterfaces:
    ConstraintStream
  All Known Subinterfaces:
    InnerBiConstraintStream<A,B>
  All Known Implementing Classes:
    BavetAbstractBiConstraintStream, BavetFilterBiConstraintStream, BavetGroupBiConstraintStream, BavetJoinBiConstraintStream, BavetJoinBridgeBiConstraintStream, BavetScoringBiConstraintStream, DroolsAbstractBiConstraintStream, DroolsFilterBiConstraintStream, DroolsGroupingBiConstraintStream, DroolsJoinBiConstraintStream, DroolsScoringBiConstraintStream

      public interface BiConstraintStream<A,B>
      extends ConstraintStream

  A `ConstraintStream` that matches two facts.
  See Also:
    `ConstraintStream`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `BiConstraintStream<A,B>` | `filter(BiPredicate<A,B> predicate)` Exhaustively test each tuple of facts against the `BiPredicate` and match if `BiPredicate.test(Object, Object)` returns true.
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass)` Create a new `TriConstraintStream` for every combination of [A, B] and C.
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass, TriJoiner<A,B,C>... joiners)` As defined by `join(Class, TriJoiner)`.
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass, TriJoiner<A,B,C> joiner)` Create a new `TriConstraintStream` for every combination of [A, B] and C for which the `BiJoiner` is true (for the properties it extracts from both facts).
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2)` As defined by `join(Class, TriJoiner)`.
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2, TriJoiner<A,B,C> joiner3)` As defined by `join(Class, TriJoiner)`.
    `default <C> TriConstraintStream<A,B,C>` | `join(Class<C> otherClass, TriJoiner<A,B,C> joiner1, TriJoiner<A,B,C> joiner2, TriJoiner<A,B,C> joiner3, TriJoiner<A,B,C> joiner4)` As defined by `join(Class, TriJoiner)`.
    `default <C> TriConstraintStream<A,B,C>` | `join(UniConstraintStream<C> otherStream)` Create a new `TriConstraintStream` for every combination of [A, B] and C.
    `<C> TriConstraintStream<A,B,C>` | `join(UniConstraintStream<C> otherStream, TriJoiner<A,B,C> joiner)` Create a new `TriConstraintStream` for every combination of [A, B] and C for which the `BiJoiner` is true (for the properties it extracts from both facts).
    `default Constraint` | `penalize(String constraintName, Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalize(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher)` As defined by `penalize(String, Score, ToIntBiFunction)`.
    `default Constraint` | `penalizeBigDecimal(String constraintName, Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalizeBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher)` As defined by `penalizeBigDecimal(String, Score, BiFunction)`.
    `Constraint` | `penalizeConfigurable(String constraintPackage, String constraintName, ToIntBiFunction<A,B> matchWeigher)` As defined by `penalizeConfigurable(String, ToIntBiFunction)`.
    `default Constraint` | `penalizeConfigurable(String constraintName, ToIntBiFunction<A,B> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `penalizeConfigurableBigDecimal(String constraintName, BiFunction<A,B,BigDecimal> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `Constraint` | `penalizeConfigurableBigDecimal(String constraintPackage, String constraintName, BiFunction<A,B,BigDecimal> matchWeigher)` As defined by `penalizeConfigurableBigDecimal(String, BiFunction)`.
    `Constraint` | `penalizeConfigurableLong(String constraintPackage, String constraintName, ToLongBiFunction<A,B> matchWeigher)` As defined by `penalizeConfigurableLong(String, ToLongBiFunction)`.
    `default Constraint` | `penalizeConfigurableLong(String constraintName, ToLongBiFunction<A,B> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `penalizeLong(String constraintName, Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalizeLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher)` As defined by `penalizeLong(String, Score, ToLongBiFunction)`.
    `default Constraint` | `reward(String constraintName, Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `reward(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntBiFunction<A,B> matchWeigher)` As defined by `reward(String, Score, ToIntBiFunction)`.
    `default Constraint` | `rewardBigDecimal(String constraintName, Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `rewardBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, BiFunction<A,B,BigDecimal> matchWeigher)` As defined by `rewardBigDecimal(String, Score, BiFunction)`.
    `Constraint` | `rewardConfigurable(String constraintPackage, String constraintName, ToIntBiFunction<A,B> matchWeigher)` As defined by `rewardConfigurable(String, ToIntBiFunction)`.
    `default Constraint` | `rewardConfigurable(String constraintName, ToIntBiFunction<A,B> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `rewardConfigurableBigDecimal(String constraintName, BiFunction<A,B,BigDecimal> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `Constraint` | `rewardConfigurableBigDecimal(String constraintPackage, String constraintName, BiFunction<A,B,BigDecimal> matchWeigher)` As defined by `rewardConfigurableBigDecimal(String, BiFunction)`.
    `Constraint` | `rewardConfigurableLong(String constraintPackage, String constraintName, ToLongBiFunction<A,B> matchWeigher)` As defined by `rewardConfigurableLong(String, ToLongBiFunction)`.
    `default Constraint` | `rewardConfigurableLong(String constraintName, ToLongBiFunction<A,B> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `rewardLong(String constraintName, Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `rewardLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongBiFunction<A,B> matchWeigher)` As defined by `rewardLong(String, Score, ToLongBiFunction)`.

    - ### Methods inherited from interface org.optaplanner.core.api.score.stream.ConstraintStream

      `getConstraintFactory, penalize, penalize, penalizeConfigurable, penalizeConfigurable, reward, reward, rewardConfigurable, rewardConfigurable`

- - ### Method Detail

    - #### filter

          BiConstraintStream<A,B> filter(BiPredicate<A,B> predicate)

      Exhaustively test each tuple of facts against the `BiPredicate` and match if `BiPredicate.test(Object, Object)` returns true.

      Important: This is slower and less scalable than `UniConstraintStream#join(UniConstraintStream, BiJoiner[])` with a proper `BiJoiner` predicate (such as `Joiners.equal(Function, Function)`, because the latter applies hashing and/or indexing, so it doesn't create every combination just to filter it out.

      Parameters:
        `predicate` - never null
      Returns:
        never null

    - #### join

          default <C> TriConstraintStream<A,B,C> join(UniConstraintStream<C> otherStream)

      Create a new `TriConstraintStream` for every combination of [A, B] and C.

      Important: `TriConstraintStream.filter(TriPredicate)` Filtering} this is slower and less scalable than a `join(UniConstraintStream, TriJoiner)`, because it doesn't apply hashing and/or indexing on the properties, so it creates and checks every combination of [A, B] and C.

      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherStream` - never null
      Returns:
        a stream that matches every combination of [A, B] and C

    - #### join

          <C> TriConstraintStream<A,B,C> join(UniConstraintStream<C> otherStream,
                                              TriJoiner<A,B,C> joiner)

      Create a new `TriConstraintStream` for every combination of [A, B] and C for which the `BiJoiner` is true (for the properties it extracts from both facts).

      Important: This is faster and more scalable than a `join` followed by a `filter`, because it applies hashing and/or indexing on the properties, so it doesn't create nor checks every combination of [A, B] and C.

      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherStream` - never null
        `joiner` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which the `BiJoiner` is true

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass)

      Create a new `TriConstraintStream` for every combination of [A, B] and C.

      Important: `TriConstraintStream.filter(TriPredicate)` Filtering} this is slower and less scalable than a `join(Class, TriJoiner)`, because it doesn't apply hashing and/or indexing on the properties, so it creates and checks every combination of [A, B] and C.

      This method is syntactic sugar for `join(UniConstraintStream)`.

      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
      Returns:
        a stream that matches every combination of [A, B] and C

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                                      TriJoiner<A,B,C> joiner)

      Create a new `TriConstraintStream` for every combination of [A, B] and C for which the `BiJoiner` is true (for the properties it extracts from both facts).

      Important: This is faster and more scalable than a `join` followed by a `filter`, because it applies hashing and/or indexing on the properties, so it doesn't create nor checks every combination of [A, B] and C.

      This method is syntactic sugar for `join(UniConstraintStream, TriJoiner)`.

      This method has overloaded methods with multiple `TriJoiner` parameters.

      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
        `joiner` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which the `BiJoiner` is true

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                                      TriJoiner<A,B,C> joiner1,
                                                      TriJoiner<A,B,C> joiner2)

      As defined by `join(Class, TriJoiner)`.
      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
        `joiner1` - never null
        `joiner2` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which all the `joiners` are true

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                                      TriJoiner<A,B,C> joiner1,
                                                      TriJoiner<A,B,C> joiner2,
                                                      TriJoiner<A,B,C> joiner3)

      As defined by `join(Class, TriJoiner)`.
      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
        `joiner1` - never null
        `joiner2` - never null
        `joiner3` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which all the `joiners` are true

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                                      TriJoiner<A,B,C> joiner1,
                                                      TriJoiner<A,B,C> joiner2,
                                                      TriJoiner<A,B,C> joiner3,
                                                      TriJoiner<A,B,C> joiner4)

      As defined by `join(Class, TriJoiner)`.
      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
        `joiner1` - never null
        `joiner2` - never null
        `joiner3` - never null
        `joiner4` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which all the `joiners` are true

    - #### join

          default <C> TriConstraintStream<A,B,C> join(Class<C> otherClass,
                                                      TriJoiner<A,B,C>... joiners)

      As defined by `join(Class, TriJoiner)`.

      This method causes Unchecked generics array creation for varargs parameter warnings, but we can't fix it with a `SafeVarargs` annotation because it's an interface method. Therefore, there are overloaded methods with up to 4 `BiJoiner` parameters.

      Type Parameters:
        `C` - the type of the third matched fact
      Parameters:
        `otherClass` - never null
        `joiners` - never null
      Returns:
        a stream that matches every combination of [A, B] and C for which all the `joiners` are true

    - #### penalize

          default Constraint penalize(String constraintName,
                                      Score<?> constraintWeight,
                                      ToIntBiFunction<A,B> matchWeigher)

      Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalize(String, Score)`.

      For non-int `Score` types use `penalizeLong(String, Score, ToLongBiFunction)` or `penalizeBigDecimal(String, Score, BiFunction)` instead.

      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalize

          Constraint penalize(String constraintPackage,
                              String constraintName,
                              Score<?> constraintWeight,
                              ToIntBiFunction<A,B> matchWeigher)

      As defined by `penalize(String, Score, ToIntBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `constraintWeight` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### penalizeLong

          default Constraint penalizeLong(String constraintName,
                                          Score<?> constraintWeight,
                                          ToLongBiFunction<A,B> matchWeigher)

      Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalize(String, Score)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalizeLong

          Constraint penalizeLong(String constraintPackage,
                                  String constraintName,
                                  Score<?> constraintWeight,
                                  ToLongBiFunction<A,B> matchWeigher)

      As defined by `penalizeLong(String, Score, ToLongBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `constraintWeight` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### penalizeBigDecimal

          default Constraint penalizeBigDecimal(String constraintName,
                                                Score<?> constraintWeight,
                                                BiFunction<A,B,BigDecimal> matchWeigher)

      Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalize(String, Score)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalizeBigDecimal

          Constraint penalizeBigDecimal(String constraintPackage,
                                        String constraintName,
                                        Score<?> constraintWeight,
                                        BiFunction<A,B,BigDecimal> matchWeigher)

      As defined by `penalizeBigDecimal(String, Score, BiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `constraintWeight` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### penalizeConfigurable

          default Constraint penalizeConfigurable(String constraintName,
                                                  ToIntBiFunction<A,B> matchWeigher)

      Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalizeConfigurable(String)`.

      For non-int `Score` types use `penalizeConfigurableLong(String, ToLongBiFunction)` or `penalizeConfigurableBigDecimal(String, BiFunction)` instead.

      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalizeConfigurable

          Constraint penalizeConfigurable(String constraintPackage,
                                          String constraintName,
                                          ToIntBiFunction<A,B> matchWeigher)

      As defined by `penalizeConfigurable(String, ToIntBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### penalizeConfigurableLong

          default Constraint penalizeConfigurableLong(String constraintName,
                                                      ToLongBiFunction<A,B> matchWeigher)

      Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalizeConfigurable(String)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalizeConfigurableLong

          Constraint penalizeConfigurableLong(String constraintPackage,
                                              String constraintName,
                                              ToLongBiFunction<A,B> matchWeigher)

      As defined by `penalizeConfigurableLong(String, ToLongBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### penalizeConfigurableBigDecimal

          default Constraint penalizeConfigurableBigDecimal(String constraintName,
                                                            BiFunction<A,B,BigDecimal> matchWeigher)

      Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.penalizeConfigurable(String)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### penalizeConfigurableBigDecimal

          Constraint penalizeConfigurableBigDecimal(String constraintPackage,
                                                    String constraintName,
                                                    BiFunction<A,B,BigDecimal> matchWeigher)

      As defined by `penalizeConfigurableBigDecimal(String, BiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### reward

          default Constraint reward(String constraintName,
                                    Score<?> constraintWeight,
                                    ToIntBiFunction<A,B> matchWeigher)

      Positively impact the `Score`: add the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.reward(String, Score)`.

      For non-int `Score` types use `rewardLong(String, Score, ToLongBiFunction)` or `rewardBigDecimal(String, Score, BiFunction)` instead.

      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### reward

          Constraint reward(String constraintPackage,
                            String constraintName,
                            Score<?> constraintWeight,
                            ToIntBiFunction<A,B> matchWeigher)

      As defined by `reward(String, Score, ToIntBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### rewardLong

          default Constraint rewardLong(String constraintName,
                                        Score<?> constraintWeight,
                                        ToLongBiFunction<A,B> matchWeigher)

      Positively impact the `Score`: add the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.reward(String, Score)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### rewardLong

          Constraint rewardLong(String constraintPackage,
                                String constraintName,
                                Score<?> constraintWeight,
                                ToLongBiFunction<A,B> matchWeigher)

      As defined by `rewardLong(String, Score, ToLongBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### rewardBigDecimal

          default Constraint rewardBigDecimal(String constraintName,
                                              Score<?> constraintWeight,
                                              BiFunction<A,B,BigDecimal> matchWeigher)

      Positively impact the `Score`: add the constraintWeight multiplied by the match weight. Otherwise as defined by `ConstraintStream.reward(String, Score)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `constraintWeight` - never null
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### rewardBigDecimal

          Constraint rewardBigDecimal(String constraintPackage,
                                      String constraintName,
                                      Score<?> constraintWeight,
                                      BiFunction<A,B,BigDecimal> matchWeigher)

      As defined by `rewardBigDecimal(String, Score, BiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### rewardConfigurable

          default Constraint rewardConfigurable(String constraintName,
                                                ToIntBiFunction<A,B> matchWeigher)

      Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.rewardConfigurable(String)`.

      For non-int `Score` types use `rewardConfigurableLong(String, ToLongBiFunction)` or `rewardConfigurableBigDecimal(String, BiFunction)` instead.

      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### rewardConfigurable

          Constraint rewardConfigurable(String constraintPackage,
                                        String constraintName,
                                        ToIntBiFunction<A,B> matchWeigher)

      As defined by `rewardConfigurable(String, ToIntBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### rewardConfigurableLong

          default Constraint rewardConfigurableLong(String constraintName,
                                                    ToLongBiFunction<A,B> matchWeigher)

      Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.rewardConfigurable(String)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### rewardConfigurableLong

          Constraint rewardConfigurableLong(String constraintPackage,
                                            String constraintName,
                                            ToLongBiFunction<A,B> matchWeigher)

      As defined by `rewardConfigurableLong(String, ToLongBiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

    - #### rewardConfigurableBigDecimal

          default Constraint rewardConfigurableBigDecimal(String constraintName,
                                                          BiFunction<A,B,BigDecimal> matchWeigher)

      Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight. Otherwise as defined by `ConstraintStream.rewardConfigurable(String)`.
      Parameters:
        `constraintName` - never null, shows up in `ConstraintMatchTotal` during score justification
        `matchWeigher` - never null, the result of this function (matchWeight) is multiplied by the constraintWeight
      Returns:
        never null

    - #### rewardConfigurableBigDecimal

          Constraint rewardConfigurableBigDecimal(String constraintPackage,
                                                  String constraintName,
                                                  BiFunction<A,B,BigDecimal> matchWeigher)

      As defined by `rewardConfigurableBigDecimal(String, BiFunction)`.
      Parameters:
        `constraintPackage` - never null
        `constraintName` - never null
        `matchWeigher` - never null
      Returns:
        never null

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