org.optaplanner.core.api.score.stream.uni

## Interface UniConstraintStream<A>

- Type Parameters:
    `A` - the type of the first and only fact in the tuple.
  All Superinterfaces:
    ConstraintStream
  All Known Subinterfaces:
    InnerUniConstraintStream<A>
  All Known Implementing Classes:
    BavetAbstractUniConstraintStream, BavetFilterUniConstraintStream, BavetFromUniConstraintStream, BavetGroupBridgeUniConstraintStream, BavetJoinBridgeUniConstraintStream, BavetScoringUniConstraintStream, DroolsAbstractUniConstraintStream, DroolsFilterUniConstraintStream, DroolsFromUniConstraintStream, DroolsGroupingUniConstraintStream, DroolsScoringUniConstraintStream

      public interface UniConstraintStream<A>
      extends ConstraintStream

  A `ConstraintStream` that matches one fact.
  See Also:
    `ConstraintStream`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `UniConstraintStream<A>` | `filter(Predicate<A> predicate)` Exhaustively test each fact against the `Predicate` and match if `Predicate.test(Object)` returns true.
    `<GroupKey_> UniConstraintStream<GroupKey_>` | `groupBy(Function<A,GroupKey_> groupKeyMapping)` Convert the `UniConstraintStream` to a different `UniConstraintStream`, containing of the set of tuples resulting from applying the group key mapping function on all tuples of the original stream.
    `<GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_>` | `groupBy(Function<A,GroupKey_> groupKeyMapping, UniConstraintCollector<A,ResultContainer_,Result_> collector)` Convert the `UniConstraintStream` to a `BiConstraintStream`, consisting of tuples which have: As the first fact, the value resulting from applying the group key mapping function on the fact from the original tuple.
    `<ResultContainer_,Result_> UniConstraintStream<Result_>` | `groupBy(UniConstraintCollector<A,ResultContainer_,Result_> collector)` Runs all tuples of the stream through a given @`UniConstraintCollector` and converts them into a new `UniConstraintStream` which only has a single tuple, the result of applying `UniConstraintCollector`.
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass)` Create a new `BiConstraintStream` for every combination of A and B.
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass, BiJoiner<A,B>... joiners)` As defined by `join(Class, BiJoiner)`.
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass, BiJoiner<A,B> joiner)` Create a new `BiConstraintStream` for every combination of A and B for which the `BiJoiner` is true (for the properties it extracts from both facts).
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass, BiJoiner<A,B> joiner1, BiJoiner<A,B> joiner2)` As defined by `join(Class, BiJoiner)`.
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass, BiJoiner<A,B> joiner1, BiJoiner<A,B> joiner2, BiJoiner<A,B> joiner3)` As defined by `join(Class, BiJoiner)`.
    `default <B> BiConstraintStream<A,B>` | `join(Class<B> otherClass, BiJoiner<A,B> joiner1, BiJoiner<A,B> joiner2, BiJoiner<A,B> joiner3, BiJoiner<A,B> joiner4)` As defined by `join(Class, BiJoiner)`.
    `default <B> BiConstraintStream<A,B>` | `join(UniConstraintStream<B> otherStream)` Create a new `BiConstraintStream` for every combination of A and B.
    `<B> BiConstraintStream<A,B>` | `join(UniConstraintStream<B> otherStream, BiJoiner<A,B> joiner)` Create a new `BiConstraintStream` for every combination of A and B for which the `BiJoiner` is true (for the properties it extracts from both facts).
    `default Constraint` | `penalize(String constraintName, Score<?> constraintWeight, ToIntFunction<A> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalize(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntFunction<A> matchWeigher)` As defined by `penalize(String, Score, ToIntFunction)`.
    `default Constraint` | `penalizeBigDecimal(String constraintName, Score<?> constraintWeight, Function<A,BigDecimal> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalizeBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, Function<A,BigDecimal> matchWeigher)` As defined by `penalizeBigDecimal(String, Score, Function)`.
    `Constraint` | `penalizeConfigurable(String constraintPackage, String constraintName, ToIntFunction<A> matchWeigher)` As defined by `penalizeConfigurable(String, ToIntFunction)`.
    `default Constraint` | `penalizeConfigurable(String constraintName, ToIntFunction<A> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `penalizeConfigurableBigDecimal(String constraintName, Function<A,BigDecimal> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `Constraint` | `penalizeConfigurableBigDecimal(String constraintPackage, String constraintName, Function<A,BigDecimal> matchWeigher)` As defined by `penalizeConfigurableBigDecimal(String, Function)`.
    `Constraint` | `penalizeConfigurableLong(String constraintPackage, String constraintName, ToLongFunction<A> matchWeigher)` As defined by `penalizeConfigurableLong(String, ToLongFunction)`.
    `default Constraint` | `penalizeConfigurableLong(String constraintName, ToLongFunction<A> matchWeigher)` Negatively impact the `Score`: subtract the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `penalizeLong(String constraintName, Score<?> constraintWeight, ToLongFunction<A> matchWeigher)` Negatively impact the `Score`: subtract the constraintWeight multiplied by the match weight.
    `Constraint` | `penalizeLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongFunction<A> matchWeigher)` As defined by `penalizeLong(String, Score, ToLongFunction)`.
    `default Constraint` | `reward(String constraintName, Score<?> constraintWeight, ToIntFunction<A> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `reward(String constraintPackage, String constraintName, Score<?> constraintWeight, ToIntFunction<A> matchWeigher)` As defined by `reward(String, Score, ToIntFunction)`.
    `default Constraint` | `rewardBigDecimal(String constraintName, Score<?> constraintWeight, Function<A,BigDecimal> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `rewardBigDecimal(String constraintPackage, String constraintName, Score<?> constraintWeight, Function<A,BigDecimal> matchWeigher)` As defined by `rewardBigDecimal(String, Score, Function)`.
    `Constraint` | `rewardConfigurable(String constraintPackage, String constraintName, ToIntFunction<A> matchWeigher)` As defined by `rewardConfigurable(String, ToIntFunction)`.
    `default Constraint` | `rewardConfigurable(String constraintName, ToIntFunction<A> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `rewardConfigurableBigDecimal(String constraintName, Function<A,BigDecimal> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `Constraint` | `rewardConfigurableBigDecimal(String constraintPackage, String constraintName, Function<A,BigDecimal> matchWeigher)` As defined by `rewardConfigurableBigDecimal(String, Function)`.
    `Constraint` | `rewardConfigurableLong(String constraintPackage, String constraintName, ToLongFunction<A> matchWeigher)` As defined by `rewardConfigurableLong(String, ToLongFunction)`.
    `default Constraint` | `rewardConfigurableLong(String constraintName, ToLongFunction<A> matchWeigher)` Positively impact the `Score`: add the `ConstraintWeight` multiplied by the match weight.
    `default Constraint` | `rewardLong(String constraintName, Score<?> constraintWeight, ToLongFunction<A> matchWeigher)` Positively impact the `Score`: add the constraintWeight multiplied by the match weight.
    `Constraint` | `rewardLong(String constraintPackage, String constraintName, Score<?> constraintWeight, ToLongFunction<A> matchWeigher)` As defined by `rewardLong(String, Score, ToLongFunction)`.

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

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

- - ### Method Detail

    - #### filter

          UniConstraintStream<A> filter(Predicate<A> predicate)

      Exhaustively test each fact against the `Predicate` and match if `Predicate.test(Object)` returns true.
      Parameters:
        `predicate` - never null
      Returns:
        never null

    - #### join

          default <B> BiConstraintStream<A,B> join(UniConstraintStream<B> otherStream)

      Create a new `BiConstraintStream` for every combination of A and B.

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

      Type Parameters:
        `B` - the type of the second matched fact
      Parameters:
        `otherStream` - never null
      Returns:
        a stream that matches every combination of A and B

    - #### join

          <B> BiConstraintStream<A,B> join(UniConstraintStream<B> otherStream,
                                           BiJoiner<A,B> joiner)

      Create a new `BiConstraintStream` for every combination of A and B 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 and B.

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

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass)

      Create a new `BiConstraintStream` for every combination of A and B.

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

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

      Type Parameters:
        `B` - the type of the second matched fact
      Parameters:
        `otherClass` - never null
      Returns:
        a stream that matches every combination of A and B

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass,
                                                   BiJoiner<A,B> joiner)

      Create a new `BiConstraintStream` for every combination of A and B 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 and B.

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

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

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

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass,
                                                   BiJoiner<A,B> joiner1,
                                                   BiJoiner<A,B> joiner2)

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

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass,
                                                   BiJoiner<A,B> joiner1,
                                                   BiJoiner<A,B> joiner2,
                                                   BiJoiner<A,B> joiner3)

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

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass,
                                                   BiJoiner<A,B> joiner1,
                                                   BiJoiner<A,B> joiner2,
                                                   BiJoiner<A,B> joiner3,
                                                   BiJoiner<A,B> joiner4)

      As defined by `join(Class, BiJoiner)`.
      Type Parameters:
        `B` - the type of the second 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 and B for which all the `joiners` are true

    - #### join

          default <B> BiConstraintStream<A,B> join(Class<B> otherClass,
                                                   BiJoiner<A,B>... joiners)

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

      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:
        `B` - the type of the second matched fact
      Parameters:
        `otherClass` - never null
        `joiners` - never null
      Returns:
        a stream that matches every combination of A and B for which all the `joiners` are true

    - #### groupBy

          <ResultContainer_,Result_> UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_> collector)

      Runs all tuples of the stream through a given @`UniConstraintCollector` and converts them into a new `UniConstraintStream` which only has a single tuple, the result of applying `UniConstraintCollector`.
      Type Parameters:
        `ResultContainer_` - the mutable accumulation type (often hidden as an implementation detail)
        `Result_` - the type of a fact in the destination `UniConstraintStream`'s tuple
      Parameters:
        `collector` - never null, the collector to perform the grouping operation with
      Returns:
        never null

    - #### groupBy

          <GroupKey_> UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_> groupKeyMapping)

      Convert the `UniConstraintStream` to a different `UniConstraintStream`, containing of the set of tuples resulting from applying the group key mapping function on all tuples of the original stream. Neither tuple of the new stream will `Objects.equals(Object, Object)` any other.
      Type Parameters:
        `GroupKey_` - the type of a fact in the destination `UniConstraintStream`'s tuple
      Parameters:
        `groupKeyMapping` - never null, mapping function to convert each element in the stream to a different element
      Returns:
        never null

    - #### groupBy

          <GroupKey_,ResultContainer_,Result_> BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_> groupKeyMapping,
                                                                                             UniConstraintCollector<A,ResultContainer_,Result_> collector)

      Convert the `UniConstraintStream` to a `BiConstraintStream`, consisting of tuples which have:
      - As the first fact, the value resulting from applying the group key mapping function on the fact from the original tuple. Neither such facts of the new stream will `Objects.equals(Object, Object)` any other.
      - As the second fact, the value of applying a given `UniConstraintCollector` on all the facts of the original tuple with a matching group key.
      Type Parameters:
        `GroupKey_` - the type of the first fact in the destination `BiConstraintStream`'s tuple
        `ResultContainer_` - the mutable accumulation type (often hidden as an implementation detail)
        `Result_` - the type of the second fact in the destination `BiConstraintStream`'s tuple
      Parameters:
        `groupKeyMapping` - never null, function to convert a fact in original tuple to a different fact
      Returns:
        never null

    - #### penalize

          default Constraint penalize(String constraintName,
                                      Score<?> constraintWeight,
                                      ToIntFunction<A> 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, ToLongFunction)` or `penalizeBigDecimal(String, Score, Function)` 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,
                              ToIntFunction<A> matchWeigher)

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

    - #### penalizeLong

          default Constraint penalizeLong(String constraintName,
                                          Score<?> constraintWeight,
                                          ToLongFunction<A> 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,
                                  ToLongFunction<A> matchWeigher)

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

    - #### penalizeBigDecimal

          default Constraint penalizeBigDecimal(String constraintName,
                                                Score<?> constraintWeight,
                                                Function<A,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,
                                        Function<A,BigDecimal> matchWeigher)

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

    - #### penalizeConfigurable

          default Constraint penalizeConfigurable(String constraintName,
                                                  ToIntFunction<A> 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, ToLongFunction)` or `penalizeConfigurableBigDecimal(String, Function)` 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,
                                          ToIntFunction<A> matchWeigher)

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

    - #### penalizeConfigurableLong

          default Constraint penalizeConfigurableLong(String constraintName,
                                                      ToLongFunction<A> 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,
                                              ToLongFunction<A> matchWeigher)

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

    - #### penalizeConfigurableBigDecimal

          default Constraint penalizeConfigurableBigDecimal(String constraintName,
                                                            Function<A,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,
                                                    Function<A,BigDecimal> matchWeigher)

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

    - #### reward

          default Constraint reward(String constraintName,
                                    Score<?> constraintWeight,
                                    ToIntFunction<A> 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, ToLongFunction)` or `rewardBigDecimal(String, Score, Function)` 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,
                            ToIntFunction<A> matchWeigher)

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

    - #### rewardLong

          default Constraint rewardLong(String constraintName,
                                        Score<?> constraintWeight,
                                        ToLongFunction<A> 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,
                                ToLongFunction<A> matchWeigher)

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

    - #### rewardBigDecimal

          default Constraint rewardBigDecimal(String constraintName,
                                              Score<?> constraintWeight,
                                              Function<A,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,
                                      Function<A,BigDecimal> matchWeigher)

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

    - #### rewardConfigurable

          default Constraint rewardConfigurable(String constraintName,
                                                ToIntFunction<A> 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, ToLongFunction)` or `rewardConfigurableBigDecimal(String, Function)` 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,
                                        ToIntFunction<A> matchWeigher)

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

    - #### rewardConfigurableLong

          default Constraint rewardConfigurableLong(String constraintName,
                                                    ToLongFunction<A> 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,
                                            ToLongFunction<A> matchWeigher)

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

    - #### rewardConfigurableBigDecimal

          default Constraint rewardConfigurableBigDecimal(String constraintName,
                                                          Function<A,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,
                                                  Function<A,BigDecimal> matchWeigher)

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

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