ReducingBindings.java
0001 /*
0002  * Copyright 2008-2017 the original author or authors.
0003  *
0004  * Licensed under the Apache License, Version 2.0 (the "License");
0005  * you may not use this file except in compliance with the License.
0006  * You may obtain a copy of the License at
0007  *
0008  *     http://www.apache.org/licenses/LICENSE-2.0
0009  *
0010  * Unless required by applicable law or agreed to in writing, software
0011  * distributed under the License is distributed on an "AS IS" BASIS,
0012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0013  * See the License for the specific language governing permissions and
0014  * limitations under the License.
0015  */
0016 package griffon.javafx.beans.binding;
0017 
0018 import javafx.beans.binding.BooleanBinding;
0019 import javafx.beans.binding.DoubleBinding;
0020 import javafx.beans.binding.FloatBinding;
0021 import javafx.beans.binding.IntegerBinding;
0022 import javafx.beans.binding.LongBinding;
0023 import javafx.beans.binding.NumberBinding;
0024 import javafx.beans.binding.ObjectBinding;
0025 import javafx.beans.binding.StringBinding;
0026 import javafx.beans.value.ObservableValue;
0027 import javafx.collections.ObservableList;
0028 import javafx.collections.ObservableMap;
0029 import javafx.collections.ObservableSet;
0030 
0031 import javax.annotation.Nonnull;
0032 import javax.annotation.Nullable;
0033 import java.util.function.BinaryOperator;
0034 import java.util.function.Function;
0035 import java.util.function.Supplier;
0036 
0037 import static java.util.Objects.requireNonNull;
0038 import static javafx.beans.binding.Bindings.createBooleanBinding;
0039 import static javafx.beans.binding.Bindings.createDoubleBinding;
0040 import static javafx.beans.binding.Bindings.createFloatBinding;
0041 import static javafx.beans.binding.Bindings.createIntegerBinding;
0042 import static javafx.beans.binding.Bindings.createLongBinding;
0043 import static javafx.beans.binding.Bindings.createObjectBinding;
0044 import static javafx.beans.binding.Bindings.createStringBinding;
0045 
0046 /**
0047  @author Andres Almiray
0048  @since 2.10.0
0049  */
0050 public final class ReducingBindings {
0051     private static final String ERROR_ITEMS_NULL = "Argument 'items' must not be null";
0052     private static final String ERROR_MAPPER_NULL = "Argument 'mapper' must not be null";
0053     private static final String ERROR_REDUCER_NULL = "Argument 'reducer' must not be null";
0054     private static final String ERROR_SUPPLIER_NULL = "Argument 'supplier' must not be null";
0055 
0056     private ReducingBindings() {
0057         // prevent instantiation
0058     }
0059 
0060     /**
0061      * Returns an object binding whose value is the reduction of all values in the map.
0062      *
0063      @param items        the observable map.
0064      @param defaultValue the value to be returned if there is no value present, may be null.
0065      @param reducer      an associative, non-interfering, stateless function for combining two values.
0066      *
0067      @return an object binding
0068      */
0069     @Nonnull
0070     public static <K, V> ObjectBinding<V> reduce(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer) {
0071         requireNonNull(items, ERROR_ITEMS_NULL);
0072         requireNonNull(reducer, ERROR_REDUCER_NULL);
0073         return createObjectBinding(() -> items.values().stream().reduce(reducer).orElse(defaultValue), items);
0074     }
0075 
0076     /**
0077      * Returns an object binding whose value is the reduction of all values in the map.
0078      *
0079      @param items    the observable map.
0080      @param supplier a {@code Supplier} whose result is returned if no value is present.
0081      @param reducer  an associative, non-interfering, stateless function for combining two values.
0082      *
0083      @return an object binding
0084      */
0085     @Nonnull
0086     public static <K, V> ObjectBinding<V> reduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer) {
0087         requireNonNull(items, ERROR_ITEMS_NULL);
0088         requireNonNull(reducer, ERROR_REDUCER_NULL);
0089         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0090         return createObjectBinding(() -> items.values().stream().reduce(reducer).orElseGet(supplier), items);
0091     }
0092 
0093     /**
0094      * Returns an object binding whose value is the reduction of all values in the map.
0095      *
0096      @param items        the observable map.
0097      @param defaultValue the value to be returned if there is no value present, may be null.
0098      @param reducer      an associative, non-interfering, stateless function for combining two values.
0099      *
0100      @return an object binding
0101      */
0102     @Nonnull
0103     public static <K, V> ObjectBinding<V> reduce(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer) {
0104         requireNonNull(reducer, ERROR_REDUCER_NULL);
0105         return createObjectBinding(() -> {
0106             BinaryOperator<V> operator = reducer.getValue();
0107             requireNonNull(operator, ERROR_REDUCER_NULL);
0108             return items.values().stream().reduce(operator).orElse(defaultValue);
0109         }, items, reducer);
0110     }
0111 
0112     /**
0113      * Returns an object binding whose value is the reduction of all values in the map.
0114      *
0115      @param items    the observable map.
0116      @param supplier a {@code Supplier} whose result is returned if no value is present.
0117      @param reducer  an associative, non-interfering, stateless function for combining two values.
0118      *
0119      @return an object binding
0120      */
0121     @Nonnull
0122     public static <K, V> ObjectBinding<V> reduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer) {
0123         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0124         requireNonNull(reducer, ERROR_REDUCER_NULL);
0125         return createObjectBinding(() -> {
0126             BinaryOperator<V> operator = reducer.getValue();
0127             requireNonNull(operator, ERROR_REDUCER_NULL);
0128             return items.values().stream().reduce(operator).orElseGet(supplier);
0129         }, items, reducer);
0130     }
0131 
0132     /**
0133      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0134      *
0135      @param items        the observable map.
0136      @param defaultValue the value to be returned if there is no value present, may be null.
0137      @param reducer      an associative, non-interfering, stateless function for combining two values.
0138      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0139      *
0140      @return a boolean binding
0141      */
0142     @Nonnull
0143     public static <K, V> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Boolean> mapper) {
0144         requireNonNull(items, ERROR_ITEMS_NULL);
0145         requireNonNull(reducer, ERROR_REDUCER_NULL);
0146         requireNonNull(mapper, ERROR_MAPPER_NULL);
0147         return createBooleanBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0148     }
0149 
0150     /**
0151      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0152      *
0153      @param items    the observable map.
0154      @param supplier a {@code Supplier} whose result is returned if no value is present.
0155      @param reducer  an associative, non-interfering, stateless function for combining two values.
0156      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0157      *
0158      @return a boolean binding
0159      */
0160     @Nonnull
0161     public static <K, V> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Boolean> mapper) {
0162         requireNonNull(items, ERROR_ITEMS_NULL);
0163         requireNonNull(reducer, ERROR_REDUCER_NULL);
0164         requireNonNull(mapper, ERROR_MAPPER_NULL);
0165         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0166         return createBooleanBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0167     }
0168 
0169     /**
0170      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0171      *
0172      @param items        the observable map.
0173      @param defaultValue the value to be returned if there is no value present, may be null.
0174      @param reducer      an associative, non-interfering, stateless function for combining two values.
0175      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0176      *
0177      @return a boolean binding
0178      */
0179     @Nonnull
0180     public static <K, V> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Boolean>> mapper) {
0181         requireNonNull(reducer, ERROR_REDUCER_NULL);
0182         requireNonNull(mapper, ERROR_MAPPER_NULL);
0183         return createBooleanBinding(() -> {
0184             BinaryOperator<V> operator = reducer.getValue();
0185             requireNonNull(operator, ERROR_REDUCER_NULL);
0186             Function<? super V, Boolean> mapperValue = mapper.getValue();
0187             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0188             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0189         }, items, reducer, mapper);
0190     }
0191 
0192     /**
0193      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0194      *
0195      @param items    the observable map.
0196      @param reducer  an associative, non-interfering, stateless function for combining two values.
0197      @param supplier a {@code Supplier} whose result is returned if no value is present.
0198      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0199      *
0200      @return a boolean binding
0201      */
0202     @Nonnull
0203     public static <K, V> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Boolean>> mapper) {
0204         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0205         requireNonNull(mapper, ERROR_MAPPER_NULL);
0206         return createBooleanBinding(() -> {
0207             BinaryOperator<V> operator = reducer.getValue();
0208             requireNonNull(operator, ERROR_REDUCER_NULL);
0209             Function<? super V, Boolean> mapperValue = mapper.getValue();
0210             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0211             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0212         }, items, reducer, mapper);
0213     }
0214 
0215     /**
0216      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0217      *
0218      @param items        the observable map.
0219      @param defaultValue the value to be returned if there is no value present, may be null.
0220      @param reducer      an associative, non-interfering, stateless function for combining two values.
0221      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0222      *
0223      @return an integer binding
0224      */
0225     @Nonnull
0226     public static <K, V> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Integer> mapper) {
0227         requireNonNull(items, ERROR_ITEMS_NULL);
0228         requireNonNull(reducer, ERROR_REDUCER_NULL);
0229         requireNonNull(mapper, ERROR_MAPPER_NULL);
0230         return createIntegerBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0231     }
0232 
0233     /**
0234      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0235      *
0236      @param items    the observable map.
0237      @param supplier a {@code Supplier} whose result is returned if no value is present.
0238      @param reducer  an associative, non-interfering, stateless function for combining two values.
0239      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0240      *
0241      @return an integer binding
0242      */
0243     @Nonnull
0244     public static <K, V> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Integer> mapper) {
0245         requireNonNull(items, ERROR_ITEMS_NULL);
0246         requireNonNull(reducer, ERROR_REDUCER_NULL);
0247         requireNonNull(mapper, ERROR_MAPPER_NULL);
0248         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0249         return createIntegerBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0250     }
0251 
0252     /**
0253      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0254      *
0255      @param items        the observable map.
0256      @param defaultValue the value to be returned if there is no value present, may be null.
0257      @param reducer      an associative, non-interfering, stateless function for combining two values.
0258      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0259      *
0260      @return an integer binding
0261      */
0262     @Nonnull
0263     public static <K, V> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Integer>> mapper) {
0264         requireNonNull(reducer, ERROR_REDUCER_NULL);
0265         requireNonNull(mapper, ERROR_MAPPER_NULL);
0266         return createIntegerBinding(() -> {
0267             BinaryOperator<V> operator = reducer.getValue();
0268             requireNonNull(operator, ERROR_REDUCER_NULL);
0269             Function<? super V, Integer> mapperValue = mapper.getValue();
0270             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0271             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0272         }, items, reducer, mapper);
0273     }
0274 
0275     /**
0276      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0277      *
0278      @param items    the observable map.
0279      @param supplier a {@code Supplier} whose result is returned if no value is present.
0280      @param reducer  an associative, non-interfering, stateless function for combining two values.
0281      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0282      *
0283      @return an integer binding
0284      */
0285     @Nonnull
0286     public static <K, V> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Integer>> mapper) {
0287         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0288         requireNonNull(mapper, ERROR_MAPPER_NULL);
0289         return createIntegerBinding(() -> {
0290             BinaryOperator<V> operator = reducer.getValue();
0291             requireNonNull(operator, ERROR_REDUCER_NULL);
0292             Function<? super V, Integer> mapperValue = mapper.getValue();
0293             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0294             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0295         }, items, reducer, mapper);
0296     }
0297 
0298     /**
0299      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0300      *
0301      @param items        the observable map.
0302      @param defaultValue the value to be returned if there is no value present, may be null.
0303      @param reducer      an associative, non-interfering, stateless function for combining two values.
0304      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0305      *
0306      @return a long binding
0307      */
0308     @Nonnull
0309     public static <K, V> LongBinding reduceThenMapToLong(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Long> mapper) {
0310         requireNonNull(items, ERROR_ITEMS_NULL);
0311         requireNonNull(reducer, ERROR_REDUCER_NULL);
0312         requireNonNull(mapper, ERROR_MAPPER_NULL);
0313         return createLongBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0314     }
0315 
0316     /**
0317      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0318      *
0319      @param items    the observable map.
0320      @param supplier a {@code Supplier} whose result is returned if no value is present.
0321      @param reducer  an associative, non-interfering, stateless function for combining two values.
0322      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0323      *
0324      @return a long binding
0325      */
0326     @Nonnull
0327     public static <K, V> LongBinding reduceThenMapToLong(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Long> mapper) {
0328         requireNonNull(items, ERROR_ITEMS_NULL);
0329         requireNonNull(reducer, ERROR_REDUCER_NULL);
0330         requireNonNull(mapper, ERROR_MAPPER_NULL);
0331         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0332         return createLongBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0333     }
0334 
0335     /**
0336      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0337      *
0338      @param items        the observable map.
0339      @param defaultValue the value to be returned if there is no value present, may be null.
0340      @param reducer      an associative, non-interfering, stateless function for combining two values.
0341      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0342      *
0343      @return a long binding
0344      */
0345     @Nonnull
0346     public static <K, V> LongBinding reduceThenMapToLong(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Long>> mapper) {
0347         requireNonNull(reducer, ERROR_REDUCER_NULL);
0348         requireNonNull(mapper, ERROR_MAPPER_NULL);
0349         return createLongBinding(() -> {
0350             BinaryOperator<V> operator = reducer.getValue();
0351             requireNonNull(operator, ERROR_REDUCER_NULL);
0352             Function<? super V, Long> mapperValue = mapper.getValue();
0353             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0354             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0355         }, items, reducer, mapper);
0356     }
0357 
0358     /**
0359      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0360      *
0361      @param items    the observable map.
0362      @param supplier a {@code Supplier} whose result is returned if no value is present.
0363      @param reducer  an associative, non-interfering, stateless function for combining two values.
0364      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0365      *
0366      @return a long binding
0367      */
0368     @Nonnull
0369     public static <K, V> LongBinding reduceThenMapToLong(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Long>> mapper) {
0370         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0371         requireNonNull(mapper, ERROR_MAPPER_NULL);
0372         return createLongBinding(() -> {
0373             BinaryOperator<V> operator = reducer.getValue();
0374             requireNonNull(operator, ERROR_REDUCER_NULL);
0375             Function<? super V, Long> mapperValue = mapper.getValue();
0376             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0377             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0378         }, items, reducer, mapper);
0379     }
0380 
0381     /**
0382      * Returns a float binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0383      *
0384      @param items        the observable map.
0385      @param defaultValue the value to be returned if there is no value present, may be null.
0386      @param reducer      an associative, non-interfering, stateless function for combining two values.
0387      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0388      *
0389      @return a float binding
0390      */
0391     @Nonnull
0392     public static <K, V> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Float> mapper) {
0393         requireNonNull(items, ERROR_ITEMS_NULL);
0394         requireNonNull(reducer, ERROR_REDUCER_NULL);
0395         requireNonNull(mapper, ERROR_MAPPER_NULL);
0396         return createFloatBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0397     }
0398 
0399     /**
0400      * Returns a float binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0401      *
0402      @param items    the observable map.
0403      @param supplier a {@code Supplier} whose result is returned if no value is present.
0404      @param reducer  an associative, non-interfering, stateless function for combining two values.
0405      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0406      *
0407      @return a float binding
0408      */
0409     @Nonnull
0410     public static <K, V> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Float> mapper) {
0411         requireNonNull(items, ERROR_ITEMS_NULL);
0412         requireNonNull(reducer, ERROR_REDUCER_NULL);
0413         requireNonNull(mapper, ERROR_MAPPER_NULL);
0414         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0415         return createFloatBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0416     }
0417 
0418     /**
0419      * Returns a float binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0420      *
0421      @param items        the observable map.
0422      @param defaultValue the value to be returned if there is no value present, may be null.
0423      @param reducer      an associative, non-interfering, stateless function for combining two values.
0424      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0425      *
0426      @return a float binding
0427      */
0428     @Nonnull
0429     public static <K, V> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Float>> mapper) {
0430         requireNonNull(reducer, ERROR_REDUCER_NULL);
0431         requireNonNull(mapper, ERROR_MAPPER_NULL);
0432         return createFloatBinding(() -> {
0433             BinaryOperator<V> operator = reducer.getValue();
0434             requireNonNull(operator, ERROR_REDUCER_NULL);
0435             Function<? super V, Float> mapperValue = mapper.getValue();
0436             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0437             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0438         }, items, reducer, mapper);
0439     }
0440 
0441     /**
0442      * Returns a float binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0443      *
0444      @param items    the observable map.
0445      @param supplier a {@code Supplier} whose result is returned if no value is present.
0446      @param reducer  an associative, non-interfering, stateless function for combining two values.
0447      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0448      *
0449      @return a float binding
0450      */
0451     @Nonnull
0452     public static <K, V> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Float>> mapper) {
0453         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0454         requireNonNull(mapper, ERROR_MAPPER_NULL);
0455         return createFloatBinding(() -> {
0456             BinaryOperator<V> operator = reducer.getValue();
0457             requireNonNull(operator, ERROR_REDUCER_NULL);
0458             Function<? super V, Float> mapperValue = mapper.getValue();
0459             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0460             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0461         }, items, reducer, mapper);
0462     }
0463 
0464     /**
0465      * Returns a double binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0466      *
0467      @param items        the observable map.
0468      @param defaultValue the value to be returned if there is no value present, may be null.
0469      @param reducer      an associative, non-interfering, stateless function for combining two values.
0470      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0471      *
0472      @return a double binding
0473      */
0474     @Nonnull
0475     public static <K, V> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Double> mapper) {
0476         requireNonNull(items, ERROR_ITEMS_NULL);
0477         requireNonNull(reducer, ERROR_REDUCER_NULL);
0478         requireNonNull(mapper, ERROR_MAPPER_NULL);
0479         return createDoubleBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0480     }
0481 
0482     /**
0483      * Returns a double binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0484      *
0485      @param items    the observable map.
0486      @param supplier a {@code Supplier} whose result is returned if no value is present.
0487      @param reducer  an associative, non-interfering, stateless function for combining two values.
0488      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0489      *
0490      @return a double binding
0491      */
0492     @Nonnull
0493     public static <K, V> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, Double> mapper) {
0494         requireNonNull(items, ERROR_ITEMS_NULL);
0495         requireNonNull(reducer, ERROR_REDUCER_NULL);
0496         requireNonNull(mapper, ERROR_MAPPER_NULL);
0497         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0498         return createDoubleBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0499     }
0500 
0501     /**
0502      * Returns a double binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0503      *
0504      @param items        the observable map.
0505      @param defaultValue the value to be returned if there is no value present, may be null.
0506      @param reducer      an associative, non-interfering, stateless function for combining two values.
0507      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0508      *
0509      @return a double binding
0510      */
0511     @Nonnull
0512     public static <K, V> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Double>> mapper) {
0513         requireNonNull(reducer, ERROR_REDUCER_NULL);
0514         requireNonNull(mapper, ERROR_MAPPER_NULL);
0515         return createDoubleBinding(() -> {
0516             BinaryOperator<V> operator = reducer.getValue();
0517             requireNonNull(operator, ERROR_REDUCER_NULL);
0518             Function<? super V, Double> mapperValue = mapper.getValue();
0519             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0520             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0521         }, items, reducer, mapper);
0522     }
0523 
0524     /**
0525      * Returns a double binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0526      *
0527      @param items    the observable map.
0528      @param supplier a {@code Supplier} whose result is returned if no value is present.
0529      @param reducer  an associative, non-interfering, stateless function for combining two values.
0530      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0531      *
0532      @return a double binding
0533      */
0534     @Nonnull
0535     public static <K, V> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, Double>> mapper) {
0536         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0537         requireNonNull(mapper, ERROR_MAPPER_NULL);
0538         return createDoubleBinding(() -> {
0539             BinaryOperator<V> operator = reducer.getValue();
0540             requireNonNull(operator, ERROR_REDUCER_NULL);
0541             Function<? super V, Double> mapperValue = mapper.getValue();
0542             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0543             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0544         }, items, reducer, mapper);
0545     }
0546 
0547     /**
0548      * Returns a String binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0549      *
0550      @param items        the observable map.
0551      @param defaultValue the value to be returned if there is no value present, may be null.
0552      @param reducer      an associative, non-interfering, stateless function for combining two values.
0553      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0554      *
0555      @return a String binding
0556      */
0557     @Nonnull
0558     public static <K, V> StringBinding reduceThenMapToString(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, String> mapper) {
0559         requireNonNull(items, ERROR_ITEMS_NULL);
0560         requireNonNull(reducer, ERROR_REDUCER_NULL);
0561         requireNonNull(mapper, ERROR_MAPPER_NULL);
0562         return createStringBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
0563     }
0564 
0565     /**
0566      * Returns a String binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0567      *
0568      @param items    the observable map.
0569      @param supplier a {@code Supplier} whose result is returned if no value is present.
0570      @param reducer  an associative, non-interfering, stateless function for combining two values.
0571      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0572      *
0573      @return a String binding
0574      */
0575     @Nonnull
0576     public static <K, V> StringBinding reduceThenMapToString(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, String> mapper) {
0577         requireNonNull(items, ERROR_ITEMS_NULL);
0578         requireNonNull(reducer, ERROR_REDUCER_NULL);
0579         requireNonNull(mapper, ERROR_MAPPER_NULL);
0580         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0581         return createStringBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
0582     }
0583 
0584     /**
0585      * Returns a String binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0586      *
0587      @param items        the observable map.
0588      @param defaultValue the value to be returned if there is no value present, may be null.
0589      @param reducer      an associative, non-interfering, stateless function for combining two values.
0590      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0591      *
0592      @return a String binding
0593      */
0594     @Nonnull
0595     public static <K, V> StringBinding reduceThenMapToString(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, String>> mapper) {
0596         requireNonNull(reducer, ERROR_REDUCER_NULL);
0597         requireNonNull(mapper, ERROR_MAPPER_NULL);
0598         return createStringBinding(() -> {
0599             BinaryOperator<V> operator = reducer.getValue();
0600             requireNonNull(operator, ERROR_REDUCER_NULL);
0601             Function<? super V, String> mapperValue = mapper.getValue();
0602             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0603             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
0604         }, items, reducer, mapper);
0605     }
0606 
0607     /**
0608      * Returns a String binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
0609      *
0610      @param items    the observable map.
0611      @param supplier a {@code Supplier} whose result is returned if no value is present.
0612      @param reducer  an associative, non-interfering, stateless function for combining two values.
0613      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0614      *
0615      @return a String binding
0616      */
0617     @Nonnull
0618     public static <K, V> StringBinding reduceThenMapToString(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, String>> mapper) {
0619         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0620         requireNonNull(mapper, ERROR_MAPPER_NULL);
0621         return createStringBinding(() -> {
0622             BinaryOperator<V> operator = reducer.getValue();
0623             requireNonNull(operator, ERROR_REDUCER_NULL);
0624             Function<? super V, String> mapperValue = mapper.getValue();
0625             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0626             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
0627         }, items, reducer, mapper);
0628     }
0629 
0630     /**
0631      * Returns an object binding whose value is the reduction of all elements in the list.
0632      *
0633      @param items        the observable list of elements.
0634      @param defaultValue the value to be returned if there is no value present, may be null.
0635      @param reducer      an associative, non-interfering, stateless function for combining two values.
0636      *
0637      @return an object binding
0638      */
0639     @Nonnull
0640     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer) {
0641         requireNonNull(items, ERROR_ITEMS_NULL);
0642         requireNonNull(reducer, ERROR_REDUCER_NULL);
0643         return createObjectBinding(() -> items.stream().reduce(reducer).orElse(defaultValue), items);
0644     }
0645 
0646     /**
0647      * Returns an object binding whose value is the reduction of all elements in the list.
0648      *
0649      @param items    the observable list of elements.
0650      @param reducer  an associative, non-interfering, stateless function for combining two values.
0651      @param supplier a {@code Supplier} whose result is returned if no value is present.
0652      *
0653      @return an object binding
0654      */
0655     @Nonnull
0656     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer) {
0657         requireNonNull(items, ERROR_ITEMS_NULL);
0658         requireNonNull(reducer, ERROR_REDUCER_NULL);
0659         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0660         return createObjectBinding(() -> items.stream().reduce(reducer).orElseGet(supplier), items);
0661     }
0662 
0663     /**
0664      * Returns an object binding whose value is the reduction of all elements in the list.
0665      *
0666      @param items        the observable list of elements.
0667      @param defaultValue the value to be returned if there is no value present, may be null.
0668      @param reducer      an associative, non-interfering, stateless function for combining two values.
0669      *
0670      @return an object binding
0671      */
0672     @Nonnull
0673     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer) {
0674         requireNonNull(reducer, ERROR_REDUCER_NULL);
0675         return createObjectBinding(() -> {
0676             BinaryOperator<T> operator = reducer.getValue();
0677             requireNonNull(operator, ERROR_REDUCER_NULL);
0678             return items.stream().reduce(operator).orElse(defaultValue);
0679         }, items, reducer);
0680     }
0681 
0682     /**
0683      * Returns an object binding whose value is the reduction of all elements in the list.
0684      *
0685      @param items    the observable list of elements.
0686      @param reducer  an associative, non-interfering, stateless function for combining two values.
0687      @param supplier a {@code Supplier} whose result is returned if no value is present.
0688      *
0689      @return an object binding
0690      */
0691     @Nonnull
0692     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer) {
0693         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0694         requireNonNull(reducer, ERROR_REDUCER_NULL);
0695         return createObjectBinding(() -> {
0696             BinaryOperator<T> operator = reducer.getValue();
0697             requireNonNull(operator, ERROR_REDUCER_NULL);
0698             return items.stream().reduce(operator).orElseGet(supplier);
0699         }, items, reducer);
0700     }
0701 
0702     /**
0703      * Returns a string binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0704      *
0705      @param items        the observable list of elements.
0706      @param defaultValue the value to be returned if there is no value present, may be null.
0707      @param reducer      an associative, non-interfering, stateless function for combining two values.
0708      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0709      *
0710      @return a string binding
0711      */
0712     @Nonnull
0713     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, String> mapper) {
0714         requireNonNull(items, ERROR_ITEMS_NULL);
0715         requireNonNull(reducer, ERROR_REDUCER_NULL);
0716         final Function<? super T, String> mapperValue = mapper != null ? mapper : String::valueOf;
0717         return createStringBinding(() -> mapperValue.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
0718     }
0719 
0720     /**
0721      * Returns a string binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0722      *
0723      @param items    the observable list of elements.
0724      @param supplier a {@code Supplier} whose result is returned if no value is present.
0725      @param reducer  an associative, non-interfering, stateless function for combining two values.
0726      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0727      *
0728      @return a string binding
0729      */
0730     @Nonnull
0731     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, String> mapper) {
0732         requireNonNull(items, ERROR_ITEMS_NULL);
0733         requireNonNull(reducer, ERROR_REDUCER_NULL);
0734         final Function<? super T, String> mapperValue = mapper != null ? mapper : String::valueOf;
0735         return createStringBinding(() -> mapperValue.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
0736     }
0737 
0738     /**
0739      * Returns a string binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0740      *
0741      @param items        the observable list of elements.
0742      @param defaultValue the value to be returned if there is no value present, may be null.
0743      @param reducer      an associative, non-interfering, stateless function for combining two values.
0744      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0745      *
0746      @return a string binding
0747      */
0748     @Nonnull
0749     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, String>> mapper) {
0750         requireNonNull(items, ERROR_ITEMS_NULL);
0751         requireNonNull(reducer, ERROR_REDUCER_NULL);
0752         requireNonNull(mapper, ERROR_MAPPER_NULL);
0753         return createStringBinding(() -> {
0754             BinaryOperator<T> operator = reducer.getValue();
0755             requireNonNull(operator, ERROR_REDUCER_NULL);
0756             final Function<? super T, String> mapperValue = mapper.getValue() != null ? mapper.getValue() : String::valueOf;
0757             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
0758         }, items, reducer, mapper);
0759     }
0760 
0761     /**
0762      * Returns a string binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0763      *
0764      @param items    the observable list of elements.
0765      @param supplier a {@code Supplier} whose result is returned if no value is present.
0766      @param reducer  an associative, non-interfering, stateless function for combining two values.
0767      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0768      *
0769      @return a string binding
0770      */
0771     @Nonnull
0772     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, String>> mapper) {
0773         requireNonNull(items, ERROR_ITEMS_NULL);
0774         requireNonNull(reducer, ERROR_REDUCER_NULL);
0775         requireNonNull(mapper, ERROR_MAPPER_NULL);
0776         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0777         return createStringBinding(() -> {
0778             BinaryOperator<T> operator = reducer.getValue();
0779             requireNonNull(operator, ERROR_REDUCER_NULL);
0780             final Function<? super T, String> mapperValue = mapper.getValue() != null ? mapper.getValue() : String::valueOf;
0781             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
0782         }, items, reducer, mapper);
0783     }
0784 
0785     /**
0786      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0787      *
0788      @param items        the observable list of elements.
0789      @param defaultValue the value to be returned if there is no value present, may be null.
0790      @param reducer      an associative, non-interfering, stateless function for combining two values.
0791      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0792      *
0793      @return an integer binding
0794      */
0795     @Nonnull
0796     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Integer> mapper) {
0797         requireNonNull(items, ERROR_ITEMS_NULL);
0798         requireNonNull(reducer, ERROR_REDUCER_NULL);
0799         requireNonNull(mapper, ERROR_MAPPER_NULL);
0800         return createIntegerBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
0801     }
0802 
0803     /**
0804      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0805      *
0806      @param items    the observable list of elements.
0807      @param supplier a {@code Supplier} whose result is returned if no value is present.
0808      @param reducer  an associative, non-interfering, stateless function for combining two values.
0809      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0810      *
0811      @return an integer binding
0812      */
0813     @Nonnull
0814     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Integer> mapper) {
0815         requireNonNull(items, ERROR_ITEMS_NULL);
0816         requireNonNull(reducer, ERROR_REDUCER_NULL);
0817         requireNonNull(mapper, ERROR_MAPPER_NULL);
0818         return createIntegerBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
0819     }
0820 
0821     /**
0822      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0823      *
0824      @param items        the observable list of elements.
0825      @param defaultValue the value to be returned if there is no value present, may be null.
0826      @param reducer      an associative, non-interfering, stateless function for combining two values.
0827      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0828      *
0829      @return an integer binding
0830      */
0831     @Nonnull
0832     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper) {
0833         requireNonNull(items, ERROR_ITEMS_NULL);
0834         requireNonNull(reducer, ERROR_REDUCER_NULL);
0835         requireNonNull(mapper, ERROR_MAPPER_NULL);
0836         return createIntegerBinding(() -> {
0837             BinaryOperator<T> operator = reducer.getValue();
0838             requireNonNull(operator, ERROR_REDUCER_NULL);
0839             final Function<? super T, Integer> mapperValue = mapper.getValue();
0840             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0841             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
0842         }, items, reducer, mapper);
0843     }
0844 
0845     /**
0846      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0847      *
0848      @param items    the observable list of elements.
0849      @param supplier a {@code Supplier} whose result is returned if no value is present.
0850      @param reducer  an associative, non-interfering, stateless function for combining two values.
0851      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0852      *
0853      @return an integer binding
0854      */
0855     @Nonnull
0856     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper) {
0857         requireNonNull(items, ERROR_ITEMS_NULL);
0858         requireNonNull(reducer, ERROR_REDUCER_NULL);
0859         requireNonNull(mapper, ERROR_MAPPER_NULL);
0860         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0861         return createIntegerBinding(() -> {
0862             BinaryOperator<T> operator = reducer.getValue();
0863             requireNonNull(operator, ERROR_REDUCER_NULL);
0864             final Function<? super T, Integer> mapperValue = mapper.getValue();
0865             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0866             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
0867         }, items, reducer, mapper);
0868     }
0869 
0870     /**
0871      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0872      *
0873      @param items        the observable list of elements.
0874      @param defaultValue the value to be returned if there is no value present, may be null.
0875      @param reducer      an associative, non-interfering, stateless function for combining two values.
0876      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0877      *
0878      @return a long binding
0879      */
0880     @Nonnull
0881     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Long> mapper) {
0882         requireNonNull(items, ERROR_ITEMS_NULL);
0883         requireNonNull(reducer, ERROR_REDUCER_NULL);
0884         requireNonNull(mapper, ERROR_MAPPER_NULL);
0885         return createLongBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
0886     }
0887 
0888     /**
0889      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0890      *
0891      @param items    the observable list of elements.
0892      @param supplier a {@code Supplier} whose result is returned if no value is present.
0893      @param reducer  an associative, non-interfering, stateless function for combining two values.
0894      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0895      *
0896      @return a long binding
0897      */
0898     @Nonnull
0899     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Long> mapper) {
0900         requireNonNull(items, ERROR_ITEMS_NULL);
0901         requireNonNull(reducer, ERROR_REDUCER_NULL);
0902         requireNonNull(mapper, ERROR_MAPPER_NULL);
0903         return createLongBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
0904     }
0905 
0906     /**
0907      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0908      *
0909      @param items        the observable list of elements.
0910      @param defaultValue the value to be returned if there is no value present, may be null.
0911      @param reducer      an associative, non-interfering, stateless function for combining two values.
0912      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0913      *
0914      @return a long binding
0915      */
0916     @Nonnull
0917     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Long>> mapper) {
0918         requireNonNull(items, ERROR_ITEMS_NULL);
0919         requireNonNull(reducer, ERROR_REDUCER_NULL);
0920         requireNonNull(mapper, ERROR_MAPPER_NULL);
0921         return createLongBinding(() -> {
0922             BinaryOperator<T> operator = reducer.getValue();
0923             requireNonNull(operator, ERROR_REDUCER_NULL);
0924             final Function<? super T, Long> mapperValue = mapper.getValue();
0925             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0926             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
0927         }, items, reducer, mapper);
0928     }
0929 
0930     /**
0931      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0932      *
0933      @param items    the observable list of elements.
0934      @param supplier a {@code Supplier} whose result is returned if no value is present.
0935      @param reducer  an associative, non-interfering, stateless function for combining two values.
0936      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0937      *
0938      @return a long binding
0939      */
0940     @Nonnull
0941     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Long>> mapper) {
0942         requireNonNull(items, ERROR_ITEMS_NULL);
0943         requireNonNull(reducer, ERROR_REDUCER_NULL);
0944         requireNonNull(mapper, ERROR_MAPPER_NULL);
0945         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
0946         return createLongBinding(() -> {
0947             BinaryOperator<T> operator = reducer.getValue();
0948             requireNonNull(operator, ERROR_REDUCER_NULL);
0949             final Function<? super T, Long> mapperValue = mapper.getValue();
0950             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
0951             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
0952         }, items, reducer, mapper);
0953     }
0954 
0955     /**
0956      * Returns a float binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0957      *
0958      @param items        the observable list of elements.
0959      @param defaultValue the value to be returned if there is no value present, may be null.
0960      @param reducer      an associative, non-interfering, stateless function for combining two values.
0961      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0962      *
0963      @return a float binding
0964      */
0965     @Nonnull
0966     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Float> mapper) {
0967         requireNonNull(items, ERROR_ITEMS_NULL);
0968         requireNonNull(reducer, ERROR_REDUCER_NULL);
0969         requireNonNull(mapper, ERROR_MAPPER_NULL);
0970         return createFloatBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
0971     }
0972 
0973     /**
0974      * Returns a float binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0975      *
0976      @param items    the observable list of elements.
0977      @param supplier a {@code Supplier} whose result is returned if no value is present.
0978      @param reducer  an associative, non-interfering, stateless function for combining two values.
0979      @param mapper   a non-interfering, stateless function to apply to the reduced value.
0980      *
0981      @return a float binding
0982      */
0983     @Nonnull
0984     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Float> mapper) {
0985         requireNonNull(items, ERROR_ITEMS_NULL);
0986         requireNonNull(reducer, ERROR_REDUCER_NULL);
0987         requireNonNull(mapper, ERROR_MAPPER_NULL);
0988         return createFloatBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
0989     }
0990 
0991     /**
0992      * Returns a float binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
0993      *
0994      @param items        the observable list of elements.
0995      @param defaultValue the value to be returned if there is no value present, may be null.
0996      @param reducer      an associative, non-interfering, stateless function for combining two values.
0997      @param mapper       a non-interfering, stateless function to apply to the reduced value.
0998      *
0999      @return a float binding
1000      */
1001     @Nonnull
1002     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Float>> mapper) {
1003         requireNonNull(items, ERROR_ITEMS_NULL);
1004         requireNonNull(reducer, ERROR_REDUCER_NULL);
1005         requireNonNull(mapper, ERROR_MAPPER_NULL);
1006         return createFloatBinding(() -> {
1007             BinaryOperator<T> operator = reducer.getValue();
1008             requireNonNull(operator, ERROR_REDUCER_NULL);
1009             final Function<? super T, Float> mapperValue = mapper.getValue();
1010             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1011             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1012         }, items, reducer, mapper);
1013     }
1014 
1015     /**
1016      * Returns a float binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1017      *
1018      @param items    the observable list of elements.
1019      @param supplier a {@code Supplier} whose result is returned if no value is present.
1020      @param reducer  an associative, non-interfering, stateless function for combining two values.
1021      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1022      *
1023      @return a float binding
1024      */
1025     @Nonnull
1026     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Float>> mapper) {
1027         requireNonNull(items, ERROR_ITEMS_NULL);
1028         requireNonNull(reducer, ERROR_REDUCER_NULL);
1029         requireNonNull(mapper, ERROR_MAPPER_NULL);
1030         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1031         return createFloatBinding(() -> {
1032             BinaryOperator<T> operator = reducer.getValue();
1033             requireNonNull(operator, ERROR_REDUCER_NULL);
1034             final Function<? super T, Float> mapperValue = mapper.getValue();
1035             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1036             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1037         }, items, reducer, mapper);
1038     }
1039 
1040     /**
1041      * Returns a double binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1042      *
1043      @param items        the observable list of elements.
1044      @param defaultValue the value to be returned if there is no value present, may be null.
1045      @param reducer      an associative, non-interfering, stateless function for combining two values.
1046      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1047      *
1048      @return a double binding
1049      */
1050     @Nonnull
1051     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Double> mapper) {
1052         requireNonNull(items, ERROR_ITEMS_NULL);
1053         requireNonNull(reducer, ERROR_REDUCER_NULL);
1054         requireNonNull(mapper, ERROR_MAPPER_NULL);
1055         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1056     }
1057 
1058     /**
1059      * Returns a double binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1060      *
1061      @param items    the observable list of elements.
1062      @param supplier a {@code Supplier} whose result is returned if no value is present.
1063      @param reducer  an associative, non-interfering, stateless function for combining two values.
1064      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1065      *
1066      @return a double binding
1067      */
1068     @Nonnull
1069     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Double> mapper) {
1070         requireNonNull(items, ERROR_ITEMS_NULL);
1071         requireNonNull(reducer, ERROR_REDUCER_NULL);
1072         requireNonNull(mapper, ERROR_MAPPER_NULL);
1073         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1074     }
1075 
1076     /**
1077      * Returns a double binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1078      *
1079      @param items        the observable list of elements.
1080      @param defaultValue the value to be returned if there is no value present, may be null.
1081      @param reducer      an associative, non-interfering, stateless function for combining two values.
1082      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1083      *
1084      @return a double binding
1085      */
1086     @Nonnull
1087     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Double>> mapper) {
1088         requireNonNull(items, ERROR_ITEMS_NULL);
1089         requireNonNull(reducer, ERROR_REDUCER_NULL);
1090         requireNonNull(mapper, ERROR_MAPPER_NULL);
1091         return createDoubleBinding(() -> {
1092             BinaryOperator<T> operator = reducer.getValue();
1093             requireNonNull(operator, ERROR_REDUCER_NULL);
1094             final Function<? super T, Double> mapperValue = mapper.getValue();
1095             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1096             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1097         }, items, reducer, mapper);
1098     }
1099 
1100     /**
1101      * Returns a double binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1102      *
1103      @param items    the observable list of elements.
1104      @param supplier a {@code Supplier} whose result is returned if no value is present.
1105      @param reducer  an associative, non-interfering, stateless function for combining two values.
1106      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1107      *
1108      @return a double binding
1109      */
1110     @Nonnull
1111     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Double>> mapper) {
1112         requireNonNull(items, ERROR_ITEMS_NULL);
1113         requireNonNull(reducer, ERROR_REDUCER_NULL);
1114         requireNonNull(mapper, ERROR_MAPPER_NULL);
1115         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1116         return createDoubleBinding(() -> {
1117             BinaryOperator<T> operator = reducer.getValue();
1118             requireNonNull(operator, ERROR_REDUCER_NULL);
1119             final Function<? super T, Double> mapperValue = mapper.getValue();
1120             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1121             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1122         }, items, reducer, mapper);
1123     }
1124 
1125     /**
1126      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1127      *
1128      @param items        the observable list of elements.
1129      @param defaultValue the value to be returned if there is no value present, may be null.
1130      @param reducer      an associative, non-interfering, stateless function for combining two values.
1131      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1132      *
1133      @return a boolean binding
1134      */
1135     @Nonnull
1136     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Boolean> mapper) {
1137         requireNonNull(items, ERROR_ITEMS_NULL);
1138         requireNonNull(reducer, ERROR_REDUCER_NULL);
1139         requireNonNull(mapper, ERROR_MAPPER_NULL);
1140         return createBooleanBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1141     }
1142 
1143     /**
1144      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1145      *
1146      @param items    the observable list of elements.
1147      @param supplier a {@code Supplier} whose result is returned if no value is present.
1148      @param reducer  an associative, non-interfering, stateless function for combining two values.
1149      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1150      *
1151      @return a boolean binding
1152      */
1153     @Nonnull
1154     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Boolean> mapper) {
1155         requireNonNull(items, ERROR_ITEMS_NULL);
1156         requireNonNull(reducer, ERROR_REDUCER_NULL);
1157         requireNonNull(mapper, ERROR_MAPPER_NULL);
1158         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1159         return createBooleanBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1160     }
1161 
1162     /**
1163      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1164      *
1165      @param items        the observable list of elements.
1166      @param defaultValue the value to be returned if there is no value present, may be null.
1167      @param reducer      an associative, non-interfering, stateless function for combining two values.
1168      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1169      *
1170      @return a boolean binding
1171      */
1172     @Nonnull
1173     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper) {
1174         requireNonNull(items, ERROR_ITEMS_NULL);
1175         requireNonNull(reducer, ERROR_REDUCER_NULL);
1176         requireNonNull(mapper, ERROR_MAPPER_NULL);
1177         return createBooleanBinding(() -> {
1178             BinaryOperator<T> operator = reducer.getValue();
1179             requireNonNull(operator, ERROR_REDUCER_NULL);
1180             final Function<? super T, Boolean> mapperValue = mapper.getValue();
1181             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1182             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1183         }, items, reducer, mapper);
1184     }
1185 
1186     /**
1187      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1188      *
1189      @param items    the observable list of elements.
1190      @param supplier a {@code Supplier} whose result is returned if no value is present.
1191      @param reducer  an associative, non-interfering, stateless function for combining two values.
1192      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1193      *
1194      @return a boolean binding
1195      */
1196     @Nonnull
1197     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper) {
1198         requireNonNull(items, ERROR_ITEMS_NULL);
1199         requireNonNull(reducer, ERROR_REDUCER_NULL);
1200         requireNonNull(mapper, ERROR_MAPPER_NULL);
1201         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1202         return createBooleanBinding(() -> {
1203             BinaryOperator<T> operator = reducer.getValue();
1204             requireNonNull(operator, ERROR_REDUCER_NULL);
1205             final Function<? super T, Boolean> mapperValue = mapper.getValue();
1206             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1207             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1208         }, items, reducer, mapper);
1209     }
1210 
1211     /**
1212      * Returns a number binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1213      *
1214      @param items        the observable list of elements.
1215      @param defaultValue the value to be returned if there is no value present, may be null.
1216      @param reducer      an associative, non-interfering, stateless function for combining two values.
1217      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1218      *
1219      @return a number binding
1220      */
1221     @Nonnull
1222     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, ? extends Number> mapper) {
1223         requireNonNull(items, ERROR_ITEMS_NULL);
1224         requireNonNull(reducer, ERROR_REDUCER_NULL);
1225         requireNonNull(mapper, ERROR_MAPPER_NULL);
1226         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)).doubleValue(), items);
1227     }
1228 
1229     /**
1230      * Returns a number binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1231      *
1232      @param items    the observable list of elements.
1233      @param supplier a {@code Supplier} whose result is returned if no value is present.
1234      @param reducer  an associative, non-interfering, stateless function for combining two values.
1235      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1236      *
1237      @return a number binding
1238      */
1239     @Nonnull
1240     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Number> mapper) {
1241         requireNonNull(items, ERROR_ITEMS_NULL);
1242         requireNonNull(reducer, ERROR_REDUCER_NULL);
1243         requireNonNull(mapper, ERROR_MAPPER_NULL);
1244         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1245         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)).doubleValue(), items);
1246     }
1247 
1248     /**
1249      * Returns a number binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1250      *
1251      @param items        the observable list of elements.
1252      @param defaultValue the value to be returned if there is no value present, may be null.
1253      @param reducer      an associative, non-interfering, stateless function for combining two values.
1254      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1255      *
1256      @return a number binding
1257      */
1258     @Nonnull
1259     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, ? extends Number>> mapper) {
1260         requireNonNull(items, ERROR_ITEMS_NULL);
1261         requireNonNull(reducer, ERROR_REDUCER_NULL);
1262         requireNonNull(mapper, ERROR_MAPPER_NULL);
1263         return createDoubleBinding(() -> {
1264             BinaryOperator<T> operator = reducer.getValue();
1265             requireNonNull(operator, ERROR_REDUCER_NULL);
1266             final Function<? super T, ? extends Number> mapperValue = mapper.getValue();
1267             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1268             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue)).doubleValue();
1269         }, items, reducer, mapper);
1270     }
1271 
1272     /**
1273      * Returns a number binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1274      *
1275      @param items    the observable list of elements.
1276      @param supplier a {@code Supplier} whose result is returned if no value is present.
1277      @param reducer  an associative, non-interfering, stateless function for combining two values.
1278      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1279      *
1280      @return a number binding
1281      */
1282     @Nonnull
1283     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Number>> mapper) {
1284         requireNonNull(items, ERROR_ITEMS_NULL);
1285         requireNonNull(reducer, ERROR_REDUCER_NULL);
1286         requireNonNull(mapper, ERROR_MAPPER_NULL);
1287         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1288         return createDoubleBinding(() -> {
1289             BinaryOperator<T> operator = reducer.getValue();
1290             requireNonNull(operator, ERROR_REDUCER_NULL);
1291             final Function<? super T, ? extends Number> mapperValue = mapper.getValue();
1292             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1293             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier)).doubleValue();
1294         }, items, reducer, mapper);
1295     }
1296 
1297     /**
1298      * Returns an object binding whose value is the reduction of all elements in the set.
1299      *
1300      @param items        the observable set of elements.
1301      @param defaultValue the value to be returned if there is no value present, may be null.
1302      @param reducer      an associative, non-interfering, stateless function for combining two values.
1303      *
1304      @return an object binding
1305      */
1306     @Nonnull
1307     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer) {
1308         requireNonNull(items, ERROR_ITEMS_NULL);
1309         requireNonNull(reducer, ERROR_REDUCER_NULL);
1310         return createObjectBinding(() -> items.stream().reduce(reducer).orElse(defaultValue), items);
1311     }
1312 
1313     /**
1314      * Returns an object binding whose value is the reduction of all elements in the set.
1315      *
1316      @param items    the observable set of elements.
1317      @param reducer  an associative, non-interfering, stateless function for combining two values.
1318      @param supplier a {@code Supplier} whose result is returned if no value is present.
1319      *
1320      @return an object binding
1321      */
1322     @Nonnull
1323     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer) {
1324         requireNonNull(items, ERROR_ITEMS_NULL);
1325         requireNonNull(reducer, ERROR_REDUCER_NULL);
1326         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1327         return createObjectBinding(() -> items.stream().reduce(reducer).orElseGet(supplier), items);
1328     }
1329 
1330     /**
1331      * Returns an object binding whose value is the reduction of all elements in the set.
1332      *
1333      @param items        the observable set of elements.
1334      @param defaultValue the value to be returned if there is no value present, may be null.
1335      @param reducer      an associative, non-interfering, stateless function for combining two values.
1336      *
1337      @return an object binding
1338      */
1339     @Nonnull
1340     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer) {
1341         requireNonNull(reducer, ERROR_REDUCER_NULL);
1342         return createObjectBinding(() -> {
1343             BinaryOperator<T> operator = reducer.getValue();
1344             requireNonNull(operator, ERROR_REDUCER_NULL);
1345             return items.stream().reduce(operator).orElse(defaultValue);
1346         }, items, reducer);
1347     }
1348 
1349     /**
1350      * Returns an object binding whose value is the reduction of all elements in the set.
1351      *
1352      @param items    the observable set of elements.
1353      @param reducer  an associative, non-interfering, stateless function for combining two values.
1354      @param supplier a {@code Supplier} whose result is returned if no value is present.
1355      *
1356      @return an object binding
1357      */
1358     @Nonnull
1359     public static <T> ObjectBinding<T> reduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer) {
1360         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1361         requireNonNull(reducer, ERROR_REDUCER_NULL);
1362         return createObjectBinding(() -> {
1363             BinaryOperator<T> operator = reducer.getValue();
1364             requireNonNull(operator, ERROR_REDUCER_NULL);
1365             return items.stream().reduce(operator).orElseGet(supplier);
1366         }, items, reducer);
1367     }
1368 
1369     /**
1370      * Returns a string binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1371      *
1372      @param items        the observable set of elements.
1373      @param defaultValue the value to be returned if there is no value present, may be null.
1374      @param reducer      an associative, non-interfering, stateless function for combining two values.
1375      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1376      *
1377      @return a string binding
1378      */
1379     @Nonnull
1380     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, String> mapper) {
1381         requireNonNull(items, ERROR_ITEMS_NULL);
1382         requireNonNull(reducer, ERROR_REDUCER_NULL);
1383         final Function<? super T, String> mapperValue = mapper != null ? mapper : String::valueOf;
1384         return createStringBinding(() -> mapperValue.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1385     }
1386 
1387     /**
1388      * Returns a string binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1389      *
1390      @param items    the observable set of elements.
1391      @param supplier a {@code Supplier} whose result is returned if no value is present.
1392      @param reducer  an associative, non-interfering, stateless function for combining two values.
1393      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1394      *
1395      @return a string binding
1396      */
1397     @Nonnull
1398     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, String> mapper) {
1399         requireNonNull(items, ERROR_ITEMS_NULL);
1400         requireNonNull(reducer, ERROR_REDUCER_NULL);
1401         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1402         final Function<? super T, String> mapperValue = mapper != null ? mapper : String::valueOf;
1403         return createStringBinding(() -> mapperValue.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1404     }
1405 
1406     /**
1407      * Returns a string binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1408      *
1409      @param items        the observable set of elements.
1410      @param defaultValue the value to be returned if there is no value present, may be null.
1411      @param reducer      an associative, non-interfering, stateless function for combining two values.
1412      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1413      *
1414      @return a string binding
1415      */
1416     @Nonnull
1417     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, String>> mapper) {
1418         requireNonNull(items, ERROR_ITEMS_NULL);
1419         requireNonNull(reducer, ERROR_REDUCER_NULL);
1420         requireNonNull(mapper, ERROR_MAPPER_NULL);
1421         return createStringBinding(() -> {
1422             BinaryOperator<T> operator = reducer.getValue();
1423             requireNonNull(operator, ERROR_REDUCER_NULL);
1424             final Function<? super T, String> mapperValue = mapper.getValue() != null ? mapper.getValue() : String::valueOf;
1425             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1426         }, items, reducer, mapper);
1427     }
1428 
1429     /**
1430      * Returns a string binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1431      *
1432      @param items    the observable set of elements.
1433      @param supplier a {@code Supplier} whose result is returned if no value is present.
1434      @param reducer  an associative, non-interfering, stateless function for combining two values.
1435      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1436      *
1437      @return a string binding
1438      */
1439     @Nonnull
1440     public static <T> StringBinding reduceThenMapToString(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, String>> mapper) {
1441         requireNonNull(items, ERROR_ITEMS_NULL);
1442         requireNonNull(reducer, ERROR_REDUCER_NULL);
1443         requireNonNull(mapper, ERROR_MAPPER_NULL);
1444         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1445         return createStringBinding(() -> {
1446             BinaryOperator<T> operator = reducer.getValue();
1447             requireNonNull(operator, ERROR_REDUCER_NULL);
1448             final Function<? super T, String> mapperValue = mapper.getValue() != null ? mapper.getValue() : String::valueOf;
1449             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1450         }, items, reducer, mapper);
1451     }
1452 
1453     /**
1454      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1455      *
1456      @param items        the observable set of elements.
1457      @param defaultValue the value to be returned if there is no value present, may be null.
1458      @param reducer      an associative, non-interfering, stateless function for combining two values.
1459      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1460      *
1461      @return an integer binding
1462      */
1463     @Nonnull
1464     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Integer> mapper) {
1465         requireNonNull(items, ERROR_ITEMS_NULL);
1466         requireNonNull(reducer, ERROR_REDUCER_NULL);
1467         requireNonNull(mapper, ERROR_MAPPER_NULL);
1468         return createIntegerBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1469     }
1470 
1471     /**
1472      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1473      *
1474      @param items    the observable set of elements.
1475      @param supplier a {@code Supplier} whose result is returned if no value is present.
1476      @param reducer  an associative, non-interfering, stateless function for combining two values.
1477      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1478      *
1479      @return an integer binding
1480      */
1481     @Nonnull
1482     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Integer> mapper) {
1483         requireNonNull(items, ERROR_ITEMS_NULL);
1484         requireNonNull(reducer, ERROR_REDUCER_NULL);
1485         requireNonNull(mapper, ERROR_MAPPER_NULL);
1486         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1487         return createIntegerBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1488     }
1489 
1490     /**
1491      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1492      *
1493      @param items        the observable set of elements.
1494      @param defaultValue the value to be returned if there is no value present, may be null.
1495      @param reducer      an associative, non-interfering, stateless function for combining two values.
1496      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1497      *
1498      @return an integer binding
1499      */
1500     @Nonnull
1501     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper) {
1502         requireNonNull(items, ERROR_ITEMS_NULL);
1503         requireNonNull(reducer, ERROR_REDUCER_NULL);
1504         requireNonNull(mapper, ERROR_MAPPER_NULL);
1505         return createIntegerBinding(() -> {
1506             BinaryOperator<T> operator = reducer.getValue();
1507             requireNonNull(operator, ERROR_REDUCER_NULL);
1508             final Function<? super T, Integer> mapperValue = mapper.getValue();
1509             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1510             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1511         }, items, reducer, mapper);
1512     }
1513 
1514     /**
1515      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1516      *
1517      @param items    the observable set of elements.
1518      @param supplier a {@code Supplier} whose result is returned if no value is present.
1519      @param reducer  an associative, non-interfering, stateless function for combining two values.
1520      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1521      *
1522      @return an integer binding
1523      */
1524     @Nonnull
1525     public static <T> IntegerBinding reduceThenMapToInteger(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper) {
1526         requireNonNull(items, ERROR_ITEMS_NULL);
1527         requireNonNull(reducer, ERROR_REDUCER_NULL);
1528         requireNonNull(mapper, ERROR_MAPPER_NULL);
1529         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1530         return createIntegerBinding(() -> {
1531             BinaryOperator<T> operator = reducer.getValue();
1532             requireNonNull(operator, ERROR_REDUCER_NULL);
1533             final Function<? super T, Integer> mapperValue = mapper.getValue();
1534             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1535             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1536         }, items, reducer, mapper);
1537     }
1538 
1539     /**
1540      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1541      *
1542      @param items        the observable set of elements.
1543      @param defaultValue the value to be returned if there is no value present, may be null.
1544      @param reducer      an associative, non-interfering, stateless function for combining two values.
1545      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1546      *
1547      @return a long binding
1548      */
1549     @Nonnull
1550     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Long> mapper) {
1551         requireNonNull(items, ERROR_ITEMS_NULL);
1552         requireNonNull(reducer, ERROR_REDUCER_NULL);
1553         requireNonNull(mapper, ERROR_MAPPER_NULL);
1554         return createLongBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1555     }
1556 
1557     /**
1558      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1559      *
1560      @param items    the observable set of elements.
1561      @param supplier a {@code Supplier} whose result is returned if no value is present.
1562      @param reducer  an associative, non-interfering, stateless function for combining two values.
1563      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1564      *
1565      @return a long binding
1566      */
1567     @Nonnull
1568     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Long> mapper) {
1569         requireNonNull(items, ERROR_ITEMS_NULL);
1570         requireNonNull(reducer, ERROR_REDUCER_NULL);
1571         requireNonNull(mapper, ERROR_MAPPER_NULL);
1572         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1573         return createLongBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1574     }
1575 
1576     /**
1577      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1578      *
1579      @param items        the observable set of elements.
1580      @param defaultValue the value to be returned if there is no value present, may be null.
1581      @param reducer      an associative, non-interfering, stateless function for combining two values.
1582      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1583      *
1584      @return a long binding
1585      */
1586     @Nonnull
1587     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Long>> mapper) {
1588         requireNonNull(items, ERROR_ITEMS_NULL);
1589         requireNonNull(reducer, ERROR_REDUCER_NULL);
1590         requireNonNull(mapper, ERROR_MAPPER_NULL);
1591         return createLongBinding(() -> {
1592             BinaryOperator<T> operator = reducer.getValue();
1593             requireNonNull(operator, ERROR_REDUCER_NULL);
1594             final Function<? super T, Long> mapperValue = mapper.getValue();
1595             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1596             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1597         }, items, reducer, mapper);
1598     }
1599 
1600     /**
1601      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1602      *
1603      @param items    the observable set of elements.
1604      @param supplier a {@code Supplier} whose result is returned if no value is present.
1605      @param reducer  an associative, non-interfering, stateless function for combining two values.
1606      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1607      *
1608      @return a long binding
1609      */
1610     @Nonnull
1611     public static <T> LongBinding reduceThenMapToLong(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Long>> mapper) {
1612         requireNonNull(items, ERROR_ITEMS_NULL);
1613         requireNonNull(reducer, ERROR_REDUCER_NULL);
1614         requireNonNull(mapper, ERROR_MAPPER_NULL);
1615         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1616         return createLongBinding(() -> {
1617             BinaryOperator<T> operator = reducer.getValue();
1618             requireNonNull(operator, ERROR_REDUCER_NULL);
1619             final Function<? super T, Long> mapperValue = mapper.getValue();
1620             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1621             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1622         }, items, reducer, mapper);
1623     }
1624 
1625     /**
1626      * Returns a float binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1627      *
1628      @param items        the observable set of elements.
1629      @param defaultValue the value to be returned if there is no value present, may be null.
1630      @param reducer      an associative, non-interfering, stateless function for combining two values.
1631      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1632      *
1633      @return a float binding
1634      */
1635     @Nonnull
1636     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Float> mapper) {
1637         requireNonNull(items, ERROR_ITEMS_NULL);
1638         requireNonNull(reducer, ERROR_REDUCER_NULL);
1639         requireNonNull(mapper, ERROR_MAPPER_NULL);
1640         return createFloatBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1641     }
1642 
1643     /**
1644      * Returns a float binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1645      *
1646      @param items    the observable set of elements.
1647      @param supplier a {@code Supplier} whose result is returned if no value is present.
1648      @param reducer  an associative, non-interfering, stateless function for combining two values.
1649      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1650      *
1651      @return a float binding
1652      */
1653     @Nonnull
1654     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Float> mapper) {
1655         requireNonNull(items, ERROR_ITEMS_NULL);
1656         requireNonNull(reducer, ERROR_REDUCER_NULL);
1657         requireNonNull(mapper, ERROR_MAPPER_NULL);
1658         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1659         return createFloatBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1660     }
1661 
1662     /**
1663      * Returns a float binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1664      *
1665      @param items        the observable set of elements.
1666      @param defaultValue the value to be returned if there is no value present, may be null.
1667      @param reducer      an associative, non-interfering, stateless function for combining two values.
1668      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1669      *
1670      @return a float binding
1671      */
1672     @Nonnull
1673     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Float>> mapper) {
1674         requireNonNull(items, ERROR_ITEMS_NULL);
1675         requireNonNull(reducer, ERROR_REDUCER_NULL);
1676         requireNonNull(mapper, ERROR_MAPPER_NULL);
1677         return createFloatBinding(() -> {
1678             BinaryOperator<T> operator = reducer.getValue();
1679             requireNonNull(operator, ERROR_REDUCER_NULL);
1680             final Function<? super T, Float> mapperValue = mapper.getValue();
1681             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1682             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1683         }, items, reducer, mapper);
1684     }
1685 
1686     /**
1687      * Returns a float binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1688      *
1689      @param items    the observable set of elements.
1690      @param supplier a {@code Supplier} whose result is returned if no value is present.
1691      @param reducer  an associative, non-interfering, stateless function for combining two values.
1692      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1693      *
1694      @return a float binding
1695      */
1696     @Nonnull
1697     public static <T> FloatBinding reduceThenMapToFloat(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Float>> mapper) {
1698         requireNonNull(items, ERROR_ITEMS_NULL);
1699         requireNonNull(reducer, ERROR_REDUCER_NULL);
1700         requireNonNull(mapper, ERROR_MAPPER_NULL);
1701         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1702         return createFloatBinding(() -> {
1703             BinaryOperator<T> operator = reducer.getValue();
1704             requireNonNull(operator, ERROR_REDUCER_NULL);
1705             final Function<? super T, Float> mapperValue = mapper.getValue();
1706             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1707             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1708         }, items, reducer, mapper);
1709     }
1710 
1711     /**
1712      * Returns a double binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1713      *
1714      @param items        the observable set of elements.
1715      @param defaultValue the value to be returned if there is no value present, may be null.
1716      @param reducer      an associative, non-interfering, stateless function for combining two values.
1717      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1718      *
1719      @return a double binding
1720      */
1721     @Nonnull
1722     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Double> mapper) {
1723         requireNonNull(items, ERROR_ITEMS_NULL);
1724         requireNonNull(reducer, ERROR_REDUCER_NULL);
1725         requireNonNull(mapper, ERROR_MAPPER_NULL);
1726         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1727     }
1728 
1729     /**
1730      * Returns a double binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1731      *
1732      @param items    the observable set of elements.
1733      @param supplier a {@code Supplier} whose result is returned if no value is present.
1734      @param reducer  an associative, non-interfering, stateless function for combining two values.
1735      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1736      *
1737      @return a double binding
1738      */
1739     @Nonnull
1740     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Double> mapper) {
1741         requireNonNull(items, ERROR_ITEMS_NULL);
1742         requireNonNull(reducer, ERROR_REDUCER_NULL);
1743         requireNonNull(mapper, ERROR_MAPPER_NULL);
1744         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1745         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1746     }
1747 
1748     /**
1749      * Returns a double binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1750      *
1751      @param items        the observable set of elements.
1752      @param defaultValue the value to be returned if there is no value present, may be null.
1753      @param reducer      an associative, non-interfering, stateless function for combining two values.
1754      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1755      *
1756      @return a double binding
1757      */
1758     @Nonnull
1759     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Double>> mapper) {
1760         requireNonNull(items, ERROR_ITEMS_NULL);
1761         requireNonNull(reducer, ERROR_REDUCER_NULL);
1762         requireNonNull(mapper, ERROR_MAPPER_NULL);
1763         return createDoubleBinding(() -> {
1764             BinaryOperator<T> operator = reducer.getValue();
1765             requireNonNull(operator, ERROR_REDUCER_NULL);
1766             final Function<? super T, Double> mapperValue = mapper.getValue();
1767             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1768             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1769         }, items, reducer, mapper);
1770     }
1771 
1772     /**
1773      * Returns a double binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1774      *
1775      @param items    the observable set of elements.
1776      @param supplier a {@code Supplier} whose result is returned if no value is present.
1777      @param reducer  an associative, non-interfering, stateless function for combining two values.
1778      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1779      *
1780      @return a double binding
1781      */
1782     @Nonnull
1783     public static <T> DoubleBinding reduceThenMapToDouble(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Double>> mapper) {
1784         requireNonNull(items, ERROR_ITEMS_NULL);
1785         requireNonNull(reducer, ERROR_REDUCER_NULL);
1786         requireNonNull(mapper, ERROR_MAPPER_NULL);
1787         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1788         return createDoubleBinding(() -> {
1789             BinaryOperator<T> operator = reducer.getValue();
1790             requireNonNull(operator, ERROR_REDUCER_NULL);
1791             final Function<? super T, Double> mapperValue = mapper.getValue();
1792             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1793             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1794         }, items, reducer, mapper);
1795     }
1796 
1797     /**
1798      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1799      *
1800      @param items        the observable set of elements.
1801      @param defaultValue the value to be returned if there is no value present, may be null.
1802      @param reducer      an associative, non-interfering, stateless function for combining two values.
1803      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1804      *
1805      @return a boolean binding
1806      */
1807     @Nonnull
1808     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Boolean> mapper) {
1809         requireNonNull(items, ERROR_ITEMS_NULL);
1810         requireNonNull(reducer, ERROR_REDUCER_NULL);
1811         requireNonNull(mapper, ERROR_MAPPER_NULL);
1812         return createBooleanBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1813     }
1814 
1815     /**
1816      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1817      *
1818      @param items    the observable set of elements.
1819      @param supplier a {@code Supplier} whose result is returned if no value is present.
1820      @param reducer  an associative, non-interfering, stateless function for combining two values.
1821      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1822      *
1823      @return a boolean binding
1824      */
1825     @Nonnull
1826     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Boolean> mapper) {
1827         requireNonNull(items, ERROR_ITEMS_NULL);
1828         requireNonNull(reducer, ERROR_REDUCER_NULL);
1829         requireNonNull(mapper, ERROR_MAPPER_NULL);
1830         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1831         return createBooleanBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
1832     }
1833 
1834     /**
1835      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1836      *
1837      @param items        the observable set of elements.
1838      @param defaultValue the value to be returned if there is no value present, may be null.
1839      @param reducer      an associative, non-interfering, stateless function for combining two values.
1840      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1841      *
1842      @return a boolean binding
1843      */
1844     @Nonnull
1845     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper) {
1846         requireNonNull(items, ERROR_ITEMS_NULL);
1847         requireNonNull(reducer, ERROR_REDUCER_NULL);
1848         requireNonNull(mapper, ERROR_MAPPER_NULL);
1849         return createBooleanBinding(() -> {
1850             BinaryOperator<T> operator = reducer.getValue();
1851             requireNonNull(operator, ERROR_REDUCER_NULL);
1852             final Function<? super T, Boolean> mapperValue = mapper.getValue();
1853             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1854             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
1855         }, items, reducer, mapper);
1856     }
1857 
1858     /**
1859      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1860      *
1861      @param items    the observable set of elements.
1862      @param supplier a {@code Supplier} whose result is returned if no value is present.
1863      @param reducer  an associative, non-interfering, stateless function for combining two values.
1864      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1865      *
1866      @return a boolean binding
1867      */
1868     @Nonnull
1869     public static <T> BooleanBinding reduceThenMapToBoolean(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper) {
1870         requireNonNull(items, ERROR_ITEMS_NULL);
1871         requireNonNull(reducer, ERROR_REDUCER_NULL);
1872         requireNonNull(mapper, ERROR_MAPPER_NULL);
1873         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1874         return createBooleanBinding(() -> {
1875             BinaryOperator<T> operator = reducer.getValue();
1876             requireNonNull(operator, ERROR_REDUCER_NULL);
1877             final Function<? super T, Boolean> mapperValue = mapper.getValue();
1878             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1879             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
1880         }, items, reducer, mapper);
1881     }
1882 
1883     /**
1884      * Returns a number binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1885      *
1886      @param items        the observable set of elements.
1887      @param defaultValue the value to be returned if there is no value present, may be null.
1888      @param reducer      an associative, non-interfering, stateless function for combining two values.
1889      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1890      *
1891      @return a number binding
1892      */
1893     @Nonnull
1894     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, ? extends Number> mapper) {
1895         requireNonNull(items, ERROR_ITEMS_NULL);
1896         requireNonNull(reducer, ERROR_REDUCER_NULL);
1897         requireNonNull(mapper, ERROR_MAPPER_NULL);
1898         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)).doubleValue(), items);
1899     }
1900 
1901     /**
1902      * Returns a number binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1903      *
1904      @param items    the observable set of elements.
1905      @param supplier a {@code Supplier} whose result is returned if no value is present.
1906      @param reducer  an associative, non-interfering, stateless function for combining two values.
1907      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1908      *
1909      @return a number binding
1910      */
1911     @Nonnull
1912     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, Number> mapper) {
1913         requireNonNull(items, ERROR_ITEMS_NULL);
1914         requireNonNull(reducer, ERROR_REDUCER_NULL);
1915         requireNonNull(mapper, ERROR_MAPPER_NULL);
1916         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1917         return createDoubleBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)).doubleValue(), items);
1918     }
1919 
1920     /**
1921      * Returns a number binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1922      *
1923      @param items        the observable set of elements.
1924      @param defaultValue the value to be returned if there is no value present, may be null.
1925      @param reducer      an associative, non-interfering, stateless function for combining two values.
1926      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1927      *
1928      @return a number binding
1929      */
1930     @Nonnull
1931     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, ? extends Number>> mapper) {
1932         requireNonNull(items, ERROR_ITEMS_NULL);
1933         requireNonNull(reducer, ERROR_REDUCER_NULL);
1934         requireNonNull(mapper, ERROR_MAPPER_NULL);
1935         return createDoubleBinding(() -> {
1936             BinaryOperator<T> operator = reducer.getValue();
1937             requireNonNull(operator, ERROR_REDUCER_NULL);
1938             final Function<? super T, ? extends Number> mapperValue = mapper.getValue();
1939             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1940             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue)).doubleValue();
1941         }, items, reducer, mapper);
1942     }
1943 
1944     /**
1945      * Returns a number binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
1946      *
1947      @param items    the observable set of elements.
1948      @param supplier a {@code Supplier} whose result is returned if no value is present.
1949      @param reducer  an associative, non-interfering, stateless function for combining two values.
1950      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1951      *
1952      @return a number binding
1953      */
1954     @Nonnull
1955     public static <T> NumberBinding reduceThenMapToNumber(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, Number>> mapper) {
1956         requireNonNull(items, ERROR_ITEMS_NULL);
1957         requireNonNull(reducer, ERROR_REDUCER_NULL);
1958         requireNonNull(mapper, ERROR_MAPPER_NULL);
1959         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
1960         return createDoubleBinding(() -> {
1961             BinaryOperator<T> operator = reducer.getValue();
1962             requireNonNull(operator, ERROR_REDUCER_NULL);
1963             final Function<? super T, ? extends Number> mapperValue = mapper.getValue();
1964             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
1965             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier)).doubleValue();
1966         }, items, reducer, mapper);
1967     }
1968 
1969     /**
1970      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1971      *
1972      @param items        the observable list of elements.
1973      @param defaultValue the value to be returned if there is no value present, may be null.
1974      @param reducer      an associative, non-interfering, stateless function for combining two values.
1975      @param mapper       a non-interfering, stateless function to apply to the reduced value.
1976      *
1977      @return an object binding
1978      */
1979     @Nonnull
1980     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, R> mapper) {
1981         requireNonNull(items, ERROR_ITEMS_NULL);
1982         requireNonNull(reducer, ERROR_REDUCER_NULL);
1983         requireNonNull(mapper, ERROR_MAPPER_NULL);
1984         return createObjectBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
1985     }
1986 
1987     /**
1988      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
1989      *
1990      @param items    the observable list of elements.
1991      @param supplier a {@code Supplier} whose result is returned if no value is present.
1992      @param reducer  an associative, non-interfering, stateless function for combining two values.
1993      @param mapper   a non-interfering, stateless function to apply to the reduced value.
1994      *
1995      @return an object binding
1996      */
1997     @Nonnull
1998     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, R> mapper) {
1999         requireNonNull(items, ERROR_ITEMS_NULL);
2000         requireNonNull(reducer, ERROR_REDUCER_NULL);
2001         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2002         requireNonNull(mapper, ERROR_MAPPER_NULL);
2003         return createObjectBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
2004     }
2005 
2006     /**
2007      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
2008      *
2009      @param items        the observable list of elements.
2010      @param defaultValue the value to be returned if there is no value present, may be null.
2011      @param reducer      an associative, non-interfering, stateless function for combining two values.
2012      @param mapper       a non-interfering, stateless function to apply to the reduced value.
2013      *
2014      @return an object binding
2015      */
2016     @Nonnull
2017     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableList<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, R>> mapper) {
2018         requireNonNull(reducer, ERROR_REDUCER_NULL);
2019         requireNonNull(mapper, ERROR_MAPPER_NULL);
2020         return createObjectBinding(() -> {
2021             BinaryOperator<T> operator = reducer.getValue();
2022             requireNonNull(operator, ERROR_REDUCER_NULL);
2023             final Function<? super T, R> mapperValue = mapper.getValue();
2024             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2025             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
2026         }, items, reducer, mapper);
2027     }
2028 
2029     /**
2030      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to the reduced value.
2031      *
2032      @param items    the observable list of elements.
2033      @param supplier a {@code Supplier} whose result is returned if no value is present.
2034      @param reducer  an associative, non-interfering, stateless function for combining two values.
2035      @param mapper   a non-interfering, stateless function to apply to the reduced value.
2036      *
2037      @return an object binding
2038      */
2039     @Nonnull
2040     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, R>> mapper) {
2041         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2042         requireNonNull(reducer, ERROR_REDUCER_NULL);
2043         requireNonNull(mapper, ERROR_MAPPER_NULL);
2044         return createObjectBinding(() -> {
2045             BinaryOperator<T> operator = reducer.getValue();
2046             requireNonNull(operator, ERROR_REDUCER_NULL);
2047             final Function<? super T, R> mapperValue = mapper.getValue();
2048             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2049             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
2050         }, items, reducer, mapper);
2051     }
2052 
2053     /**
2054      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
2055      *
2056      @param items        the observable set of elements.
2057      @param defaultValue the value to be returned if there is no value present, may be null.
2058      @param reducer      an associative, non-interfering, stateless function for combining two values.
2059      @param mapper       a non-interfering, stateless function to apply to the reduced value.
2060      *
2061      @return an object binding
2062      */
2063     @Nonnull
2064     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, R> mapper) {
2065         requireNonNull(items, ERROR_ITEMS_NULL);
2066         requireNonNull(reducer, ERROR_REDUCER_NULL);
2067         return createObjectBinding(() -> mapper.apply(items.stream().reduce(reducer).orElse(defaultValue)), items);
2068     }
2069 
2070     /**
2071      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
2072      *
2073      @param items    the observable set of elements.
2074      @param supplier a {@code Supplier} whose result is returned if no value is present.
2075      @param reducer  an associative, non-interfering, stateless function for combining two values.
2076      @param mapper   a non-interfering, stateless function to apply to the reduced value.
2077      *
2078      @return an object binding
2079      */
2080     @Nonnull
2081     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final BinaryOperator<T> reducer, @Nonnull final Function<? super T, R> mapper) {
2082         requireNonNull(items, ERROR_ITEMS_NULL);
2083         requireNonNull(reducer, ERROR_REDUCER_NULL);
2084         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2085         requireNonNull(mapper, ERROR_MAPPER_NULL);
2086         return createObjectBinding(() -> mapper.apply(items.stream().reduce(reducer).orElseGet(supplier)), items);
2087     }
2088 
2089     /**
2090      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
2091      *
2092      @param items        the observable set of elements.
2093      @param defaultValue the value to be returned if there is no value present, may be null.
2094      @param reducer      an associative, non-interfering, stateless function for combining two values.
2095      @param mapper       a non-interfering, stateless function to apply to the reduced value.
2096      *
2097      @return an object binding
2098      */
2099     @Nonnull
2100     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableSet<T> items, @Nullable final T defaultValue, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, R>> mapper) {
2101         requireNonNull(reducer, ERROR_REDUCER_NULL);
2102         requireNonNull(mapper, ERROR_MAPPER_NULL);
2103         return createObjectBinding(() -> {
2104             BinaryOperator<T> operator = reducer.getValue();
2105             requireNonNull(operator, ERROR_REDUCER_NULL);
2106             final Function<? super T, R> mapperValue = mapper.getValue();
2107             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2108             return mapperValue.apply(items.stream().reduce(operator).orElse(defaultValue));
2109         }, items, reducer, mapper);
2110     }
2111 
2112     /**
2113      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to the reduced value.
2114      *
2115      @param items    the observable set of elements.
2116      @param supplier a {@code Supplier} whose result is returned if no value is present.
2117      @param reducer  an associative, non-interfering, stateless function for combining two values.
2118      @param mapper   a non-interfering, stateless function to apply to the reduced value.
2119      *
2120      @return an object binding
2121      */
2122     @Nonnull
2123     public static <T, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<T> supplier, @Nonnull final ObservableValue<BinaryOperator<T>> reducer, @Nonnull final ObservableValue<Function<? super T, R>> mapper) {
2124         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2125         requireNonNull(reducer, ERROR_REDUCER_NULL);
2126         requireNonNull(mapper, ERROR_MAPPER_NULL);
2127         return createObjectBinding(() -> {
2128             BinaryOperator<T> operator = reducer.getValue();
2129             requireNonNull(operator, ERROR_REDUCER_NULL);
2130             final Function<? super T, R> mapperValue = mapper.getValue();
2131             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2132             return mapperValue.apply(items.stream().reduce(operator).orElseGet(supplier));
2133         }, items, reducer, mapper);
2134     }
2135 
2136     /**
2137      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
2138      *
2139      @param items        the observable map.
2140      @param defaultValue the value to be returned if there is no value present, may be null.
2141      @param reducer      an associative, non-interfering, stateless function for combining two values.
2142      @param mapper       a non-interfering, stateless function to apply to the reduced value.
2143      *
2144      @return an object binding
2145      */
2146     @Nonnull
2147     public static <K, V, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, R> mapper) {
2148         requireNonNull(items, ERROR_ITEMS_NULL);
2149         requireNonNull(reducer, ERROR_REDUCER_NULL);
2150         requireNonNull(mapper, ERROR_MAPPER_NULL);
2151         return createObjectBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElse(defaultValue)), items);
2152     }
2153 
2154     /**
2155      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
2156      *
2157      @param items    the observable map.
2158      @param supplier a {@code Supplier} whose result is returned if no value is present.
2159      @param reducer  an associative, non-interfering, stateless function for combining two values.
2160      @param mapper   a non-interfering, stateless function to apply to the reduced value.
2161      *
2162      @return an object binding
2163      */
2164     @Nonnull
2165     public static <K, V, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final BinaryOperator<V> reducer, @Nonnull final Function<? super V, R> mapper) {
2166         requireNonNull(items, ERROR_ITEMS_NULL);
2167         requireNonNull(reducer, ERROR_REDUCER_NULL);
2168         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2169         requireNonNull(mapper, ERROR_MAPPER_NULL);
2170         return createObjectBinding(() -> mapper.apply(items.values().stream().reduce(reducer).orElseGet(supplier)), items);
2171     }
2172 
2173     /**
2174      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
2175      *
2176      @param items        the observable map.
2177      @param defaultValue the value to be returned if there is no value present, may be null.
2178      @param reducer      an associative, non-interfering, stateless function for combining two values.
2179      @param mapper       a non-interfering, stateless function to apply to the reduced value.
2180      *
2181      @return an object binding
2182      */
2183     @Nonnull
2184     public static <K, V, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableMap<K, V> items, @Nullable final V defaultValue, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, R>> mapper) {
2185         requireNonNull(reducer, ERROR_REDUCER_NULL);
2186         requireNonNull(mapper, ERROR_MAPPER_NULL);
2187         return createObjectBinding(() -> {
2188             BinaryOperator<V> operator = reducer.getValue();
2189             requireNonNull(operator, ERROR_REDUCER_NULL);
2190             final Function<? super V, R> mapperValue = mapper.getValue();
2191             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2192             return mapperValue.apply(items.values().stream().reduce(operator).orElse(defaultValue));
2193         }, items, reducer, mapper);
2194     }
2195 
2196     /**
2197      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to the reduced value.
2198      *
2199      @param items    the observable map.
2200      @param supplier a {@code Supplier} whose result is returned if no value is present.
2201      @param reducer  an associative, non-interfering, stateless function for combining two values.
2202      @param mapper   a non-interfering, stateless function to apply to the reduced value.
2203      *
2204      @return an object binding
2205      */
2206     @Nonnull
2207     public static <K, V, R> ObjectBinding<R> reduceThenMap(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<V> supplier, @Nonnull final ObservableValue<BinaryOperator<V>> reducer, @Nonnull final ObservableValue<Function<? super V, R>> mapper) {
2208         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2209         requireNonNull(reducer, ERROR_REDUCER_NULL);
2210         requireNonNull(mapper, ERROR_MAPPER_NULL);
2211         return createObjectBinding(() -> {
2212             BinaryOperator<V> operator = reducer.getValue();
2213             requireNonNull(operator, ERROR_REDUCER_NULL);
2214             final Function<? super V, R> mapperValue = mapper.getValue();
2215             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2216             return mapperValue.apply(items.values().stream().reduce(operator).orElseGet(supplier));
2217         }, items, reducer, mapper);
2218     }
2219 
2220     /**
2221      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2222      *
2223      @param items        the observable list of elements.
2224      @param defaultValue the value to be returned if there is no value present, may be null.
2225      @param mapper       a non-interfering, stateless function to apply to each element.
2226      @param reducer      an associative, non-interfering, stateless function for combining two values.
2227      *
2228      @return an object binding
2229      */
2230     @Nonnull
2231     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableList<T> items, @Nullable final R defaultValue, @Nonnull final Function<? super T, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2232         requireNonNull(items, ERROR_ITEMS_NULL);
2233         requireNonNull(reducer, ERROR_REDUCER_NULL);
2234         requireNonNull(mapper, ERROR_MAPPER_NULL);
2235         return createObjectBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2236     }
2237 
2238     /**
2239      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2240      *
2241      @param items    the observable list of elements.
2242      @param supplier a {@code Supplier} whose result is returned if no value is present.
2243      @param mapper   a non-interfering, stateless function to apply to each element.
2244      @param reducer  an associative, non-interfering, stateless function for combining two values.
2245      *
2246      @return an object binding
2247      */
2248     @Nonnull
2249     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<R> supplier, @Nonnull final Function<? super T, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2250         requireNonNull(items, ERROR_ITEMS_NULL);
2251         requireNonNull(reducer, ERROR_REDUCER_NULL);
2252         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2253         requireNonNull(mapper, ERROR_MAPPER_NULL);
2254         return createObjectBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2255     }
2256 
2257     /**
2258      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2259      *
2260      @param items        the observable list of elements.
2261      @param defaultValue the value to be returned if there is no value present, may be null.
2262      @param mapper       a non-interfering, stateless function to apply to each element.
2263      @param reducer      an associative, non-interfering, stateless function for combining two values.
2264      *
2265      @return an object binding
2266      */
2267     @Nonnull
2268     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableList<T> items, @Nullable final R defaultValue, @Nonnull final ObservableValue<Function<? super T, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2269         requireNonNull(reducer, ERROR_REDUCER_NULL);
2270         requireNonNull(mapper, ERROR_MAPPER_NULL);
2271         return createObjectBinding(() -> {
2272             BinaryOperator<R> reducerValue = reducer.getValue();
2273             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2274             final Function<? super T, R> mapperValue = mapper.getValue();
2275             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2276             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2277         }, items, reducer, mapper);
2278     }
2279 
2280     /**
2281      * Returns an object binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2282      *
2283      @param items    the observable list of elements.
2284      @param supplier a {@code Supplier} whose result is returned if no value is present.
2285      @param mapper   a non-interfering, stateless function to apply to each element.
2286      @param reducer  an associative, non-interfering, stateless function for combining two values.
2287      *
2288      @return an object binding
2289      */
2290     @Nonnull
2291     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<R> supplier, @Nonnull final ObservableValue<Function<? super T, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2292         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2293         requireNonNull(reducer, ERROR_REDUCER_NULL);
2294         requireNonNull(mapper, ERROR_MAPPER_NULL);
2295         return createObjectBinding(() -> {
2296             BinaryOperator<R> reducerValue = reducer.getValue();
2297             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2298             final Function<? super T, R> mapperValue = mapper.getValue();
2299             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2300             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2301         }, items, reducer, mapper);
2302     }
2303 
2304     /**
2305      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2306      *
2307      @param items        the observable set of elements.
2308      @param defaultValue the value to be returned if there is no value present, may be null.
2309      @param mapper       a non-interfering, stateless function to apply to each element.
2310      @param reducer      an associative, non-interfering, stateless function for combining two values.
2311      *
2312      @return an object binding
2313      */
2314     @Nonnull
2315     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final R defaultValue, @Nonnull final Function<? super T, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2316         requireNonNull(items, ERROR_ITEMS_NULL);
2317         requireNonNull(reducer, ERROR_REDUCER_NULL);
2318         return createObjectBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2319     }
2320 
2321     /**
2322      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2323      *
2324      @param items    the observable set of elements.
2325      @param supplier a {@code Supplier} whose result is returned if no value is present.
2326      @param mapper   a non-interfering, stateless function to apply to each element.
2327      @param reducer  an associative, non-interfering, stateless function for combining two values.
2328      *
2329      @return an object binding
2330      */
2331     @Nonnull
2332     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<R> supplier, @Nonnull final Function<? super T, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2333         requireNonNull(items, ERROR_ITEMS_NULL);
2334         requireNonNull(reducer, ERROR_REDUCER_NULL);
2335         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2336         requireNonNull(mapper, ERROR_MAPPER_NULL);
2337         return createObjectBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2338     }
2339 
2340     /**
2341      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2342      *
2343      @param items        the observable set of elements.
2344      @param defaultValue the value to be returned if there is no value present, may be null.
2345      @param mapper       a non-interfering, stateless function to apply to each element.
2346      @param reducer      an associative, non-interfering, stateless function for combining two values.
2347      *
2348      @return an object binding
2349      */
2350     @Nonnull
2351     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final R defaultValue, @Nonnull final ObservableValue<Function<? super T, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2352         requireNonNull(reducer, ERROR_REDUCER_NULL);
2353         requireNonNull(mapper, ERROR_MAPPER_NULL);
2354         return createObjectBinding(() -> {
2355             BinaryOperator<R> reducerValue = reducer.getValue();
2356             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2357             final Function<? super T, R> mapperValue = mapper.getValue();
2358             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2359             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2360         }, items, reducer, mapper);
2361     }
2362 
2363     /**
2364      * Returns an object binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2365      *
2366      @param items    the observable set of elements.
2367      @param supplier a {@code Supplier} whose result is returned if no value is present.
2368      @param mapper   a non-interfering, stateless function to apply to each element.
2369      @param reducer  an associative, non-interfering, stateless function for combining two values.
2370      *
2371      @return an object binding
2372      */
2373     @Nonnull
2374     public static <T, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<R> supplier, @Nonnull final ObservableValue<Function<? super T, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2375         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2376         requireNonNull(reducer, ERROR_REDUCER_NULL);
2377         requireNonNull(mapper, ERROR_MAPPER_NULL);
2378         return createObjectBinding(() -> {
2379             BinaryOperator<R> reducerValue = reducer.getValue();
2380             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2381             final Function<? super T, R> mapperValue = mapper.getValue();
2382             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2383             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2384         }, items, reducer, mapper);
2385     }
2386 
2387     /**
2388      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2389      *
2390      @param items        the observable map.
2391      @param defaultValue the value to be returned if there is no value present, may be null.
2392      @param mapper       a non-interfering, stateless function to apply to each value.
2393      @param reducer      an associative, non-interfering, stateless function for combining two values.
2394      *
2395      @return an object binding
2396      */
2397     @Nonnull
2398     public static <K, V, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final R defaultValue, @Nonnull final Function<? super V, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2399         requireNonNull(items, ERROR_ITEMS_NULL);
2400         requireNonNull(reducer, ERROR_REDUCER_NULL);
2401         requireNonNull(mapper, ERROR_MAPPER_NULL);
2402         return createObjectBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2403     }
2404 
2405     /**
2406      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2407      *
2408      @param items    the observable map.
2409      @param supplier a {@code Supplier} whose result is returned if no value is present.
2410      @param mapper   a non-interfering, stateless function to apply to each value.
2411      @param reducer  an associative, non-interfering, stateless function for combining two values.
2412      *
2413      @return an object binding
2414      */
2415     @Nonnull
2416     public static <K, V, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<R> supplier, @Nonnull final Function<? super V, R> mapper, @Nonnull final BinaryOperator<R> reducer) {
2417         requireNonNull(items, ERROR_ITEMS_NULL);
2418         requireNonNull(reducer, ERROR_REDUCER_NULL);
2419         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2420         requireNonNull(mapper, ERROR_MAPPER_NULL);
2421         return createObjectBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2422     }
2423 
2424     /**
2425      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2426      *
2427      @param items        the observable map.
2428      @param defaultValue the value to be returned if there is no value present, may be null.
2429      @param mapper       a non-interfering, stateless function to apply to each value.
2430      @param reducer      an associative, non-interfering, stateless function for combining two values.
2431      *
2432      @return an object binding
2433      */
2434     @Nonnull
2435     public static <K, V, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final R defaultValue, @Nonnull final ObservableValue<Function<? super V, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2436         requireNonNull(reducer, ERROR_REDUCER_NULL);
2437         requireNonNull(mapper, ERROR_MAPPER_NULL);
2438         return createObjectBinding(() -> {
2439             BinaryOperator<R> reducerValue = reducer.getValue();
2440             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2441             final Function<? super V, R> mapperValue = mapper.getValue();
2442             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2443             return items.values().stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2444         }, items, reducer, mapper);
2445     }
2446 
2447     /**
2448      * Returns an object binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2449      *
2450      @param items    the observable map.
2451      @param supplier a {@code Supplier} whose result is returned if no value is present.
2452      @param mapper   a non-interfering, stateless function to apply to each value.
2453      @param reducer  an associative, non-interfering, stateless function for combining two values.
2454      *
2455      @return an object binding
2456      */
2457     @Nonnull
2458     public static <K, V, R> ObjectBinding<R> mapThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<R> supplier, @Nonnull final ObservableValue<Function<? super V, R>> mapper, @Nonnull final ObservableValue<BinaryOperator<R>> reducer) {
2459         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2460         requireNonNull(reducer, ERROR_REDUCER_NULL);
2461         requireNonNull(mapper, ERROR_MAPPER_NULL);
2462         return createObjectBinding(() -> {
2463             BinaryOperator<R> reducerValue = reducer.getValue();
2464             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2465             final Function<? super V, R> mapperValue = mapper.getValue();
2466             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2467             return items.values().stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2468         }, items, reducer, mapper);
2469     }
2470 
2471     /**
2472      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2473      *
2474      @param items        the observable list of elements.
2475      @param defaultValue the value to be returned if there is no value present, may be null.
2476      @param mapper       a non-interfering, stateless function to apply to each element.
2477      @param reducer      an associative, non-interfering, stateless function for combining two values.
2478      *
2479      @return a boolean binding
2480      */
2481     @Nonnull
2482     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Boolean defaultValue, @Nonnull final Function<? super T, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2483         requireNonNull(items, ERROR_ITEMS_NULL);
2484         requireNonNull(reducer, ERROR_REDUCER_NULL);
2485         requireNonNull(mapper, ERROR_MAPPER_NULL);
2486         return createBooleanBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2487     }
2488 
2489     /**
2490      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2491      *
2492      @param items    the observable list of elements.
2493      @param supplier a {@code Supplier} whose result is returned if no value is present.
2494      @param mapper   a non-interfering, stateless function to apply to each element.
2495      @param reducer  an associative, non-interfering, stateless function for combining two values.
2496      *
2497      @return a boolean binding
2498      */
2499     @Nonnull
2500     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final Function<? super T, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2501         requireNonNull(items, ERROR_ITEMS_NULL);
2502         requireNonNull(reducer, ERROR_REDUCER_NULL);
2503         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2504         requireNonNull(mapper, ERROR_MAPPER_NULL);
2505         return createBooleanBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2506     }
2507 
2508     /**
2509      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2510      *
2511      @param items        the observable list of elements.
2512      @param defaultValue the value to be returned if there is no value present, may be null.
2513      @param mapper       a non-interfering, stateless function to apply to each element.
2514      @param reducer      an associative, non-interfering, stateless function for combining two values.
2515      *
2516      @return a boolean binding
2517      */
2518     @Nonnull
2519     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Boolean defaultValue, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2520         requireNonNull(reducer, ERROR_REDUCER_NULL);
2521         requireNonNull(mapper, ERROR_MAPPER_NULL);
2522         return createBooleanBinding(() -> {
2523             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2524             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2525             final Function<? super T, Boolean> mapperValue = mapper.getValue();
2526             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2527             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2528         }, items, reducer, mapper);
2529     }
2530 
2531     /**
2532      * Returns a boolean binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2533      *
2534      @param items    the observable list of elements.
2535      @param supplier a {@code Supplier} whose result is returned if no value is present.
2536      @param mapper   a non-interfering, stateless function to apply to each element.
2537      @param reducer  an associative, non-interfering, stateless function for combining two values.
2538      *
2539      @return a boolean binding
2540      */
2541     @Nonnull
2542     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2543         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2544         requireNonNull(reducer, ERROR_REDUCER_NULL);
2545         requireNonNull(mapper, ERROR_MAPPER_NULL);
2546         return createBooleanBinding(() -> {
2547             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2548             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2549             final Function<? super T, Boolean> mapperValue = mapper.getValue();
2550             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2551             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2552         }, items, reducer, mapper);
2553     }
2554 
2555     /**
2556      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2557      *
2558      @param items        the observable set of elements.
2559      @param defaultValue the value to be returned if there is no value present, may be null.
2560      @param mapper       a non-interfering, stateless function to apply to each element.
2561      @param reducer      an associative, non-interfering, stateless function for combining two values.
2562      *
2563      @return a boolean binding
2564      */
2565     @Nonnull
2566     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Boolean defaultValue, @Nonnull final Function<? super T, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2567         requireNonNull(items, ERROR_ITEMS_NULL);
2568         requireNonNull(reducer, ERROR_REDUCER_NULL);
2569         return createBooleanBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2570     }
2571 
2572     /**
2573      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2574      *
2575      @param items    the observable set of elements.
2576      @param supplier a {@code Supplier} whose result is returned if no value is present.
2577      @param mapper   a non-interfering, stateless function to apply to each element.
2578      @param reducer  an associative, non-interfering, stateless function for combining two values.
2579      *
2580      @return a boolean binding
2581      */
2582     @Nonnull
2583     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final Function<? super T, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2584         requireNonNull(items, ERROR_ITEMS_NULL);
2585         requireNonNull(reducer, ERROR_REDUCER_NULL);
2586         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2587         requireNonNull(mapper, ERROR_MAPPER_NULL);
2588         return createBooleanBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2589     }
2590 
2591     /**
2592      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2593      *
2594      @param items        the observable set of elements.
2595      @param defaultValue the value to be returned if there is no value present, may be null.
2596      @param mapper       a non-interfering, stateless function to apply to each element.
2597      @param reducer      an associative, non-interfering, stateless function for combining two values.
2598      *
2599      @return a boolean binding
2600      */
2601     @Nonnull
2602     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Boolean defaultValue, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2603         requireNonNull(reducer, ERROR_REDUCER_NULL);
2604         requireNonNull(mapper, ERROR_MAPPER_NULL);
2605         return createBooleanBinding(() -> {
2606             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2607             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2608             final Function<? super T, Boolean> mapperValue = mapper.getValue();
2609             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2610             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2611         }, items, reducer, mapper);
2612     }
2613 
2614     /**
2615      * Returns a boolean binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2616      *
2617      @param items    the observable set of elements.
2618      @param supplier a {@code Supplier} whose result is returned if no value is present.
2619      @param mapper   a non-interfering, stateless function to apply to each element.
2620      @param reducer  an associative, non-interfering, stateless function for combining two values.
2621      *
2622      @return a boolean binding
2623      */
2624     @Nonnull
2625     public static <T> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final ObservableValue<Function<? super T, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2626         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2627         requireNonNull(reducer, ERROR_REDUCER_NULL);
2628         requireNonNull(mapper, ERROR_MAPPER_NULL);
2629         return createBooleanBinding(() -> {
2630             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2631             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2632             final Function<? super T, Boolean> mapperValue = mapper.getValue();
2633             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2634             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2635         }, items, reducer, mapper);
2636     }
2637 
2638     /**
2639      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2640      *
2641      @param items        the observable map.
2642      @param defaultValue the value to be returned if there is no value present, may be null.
2643      @param mapper       a non-interfering, stateless function to apply to each value.
2644      @param reducer      an associative, non-interfering, stateless function for combining two values.
2645      *
2646      @return a boolean binding
2647      */
2648     @Nonnull
2649     public static <K, V> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final Boolean defaultValue, @Nonnull final Function<? super V, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2650         requireNonNull(items, ERROR_ITEMS_NULL);
2651         requireNonNull(reducer, ERROR_REDUCER_NULL);
2652         requireNonNull(mapper, ERROR_MAPPER_NULL);
2653         return createBooleanBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2654     }
2655 
2656     /**
2657      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2658      *
2659      @param items    the observable map.
2660      @param supplier a {@code Supplier} whose result is returned if no value is present.
2661      @param mapper   a non-interfering, stateless function to apply to each value.
2662      @param reducer  an associative, non-interfering, stateless function for combining two values.
2663      *
2664      @return a boolean binding
2665      */
2666     @Nonnull
2667     public static <K, V> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final Function<? super V, Boolean> mapper, @Nonnull final BinaryOperator<Boolean> reducer) {
2668         requireNonNull(items, ERROR_ITEMS_NULL);
2669         requireNonNull(reducer, ERROR_REDUCER_NULL);
2670         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2671         requireNonNull(mapper, ERROR_MAPPER_NULL);
2672         return createBooleanBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2673     }
2674 
2675     /**
2676      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2677      *
2678      @param items        the observable map.
2679      @param defaultValue the value to be returned if there is no value present, may be null.
2680      @param mapper       a non-interfering, stateless function to apply to each value.
2681      @param reducer      an associative, non-interfering, stateless function for combining two values.
2682      *
2683      @return a boolean binding
2684      */
2685     @Nonnull
2686     public static <K, V> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final Boolean defaultValue, @Nonnull final ObservableValue<Function<? super V, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2687         requireNonNull(reducer, ERROR_REDUCER_NULL);
2688         requireNonNull(mapper, ERROR_MAPPER_NULL);
2689         return createBooleanBinding(() -> {
2690             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2691             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2692             final Function<? super V, Boolean> mapperValue = mapper.getValue();
2693             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2694             return items.values().stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2695         }, items, reducer, mapper);
2696     }
2697 
2698     /**
2699      * Returns a boolean binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2700      *
2701      @param items    the observable map.
2702      @param supplier a {@code Supplier} whose result is returned if no value is present.
2703      @param mapper   a non-interfering, stateless function to apply to each value.
2704      @param reducer  an associative, non-interfering, stateless function for combining two values.
2705      *
2706      @return a boolean binding
2707      */
2708     @Nonnull
2709     public static <K, V> BooleanBinding mapToBooleanThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<Boolean> supplier, @Nonnull final ObservableValue<Function<? super V, Boolean>> mapper, @Nonnull final ObservableValue<BinaryOperator<Boolean>> reducer) {
2710         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2711         requireNonNull(reducer, ERROR_REDUCER_NULL);
2712         requireNonNull(mapper, ERROR_MAPPER_NULL);
2713         return createBooleanBinding(() -> {
2714             BinaryOperator<Boolean> reducerValue = reducer.getValue();
2715             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2716             final Function<? super V, Boolean> mapperValue = mapper.getValue();
2717             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2718             return items.values().stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2719         }, items, reducer, mapper);
2720     }
2721 
2722     /**
2723      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2724      *
2725      @param items        the observable list of elements.
2726      @param defaultValue the value to be returned if there is no value present, may be null.
2727      @param mapper       a non-interfering, stateless function to apply to each element.
2728      @param reducer      an associative, non-interfering, stateless function for combining two values.
2729      *
2730      @return an integer binding
2731      */
2732     @Nonnull
2733     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Integer defaultValue, @Nonnull final Function<? super T, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2734         requireNonNull(items, ERROR_ITEMS_NULL);
2735         requireNonNull(reducer, ERROR_REDUCER_NULL);
2736         requireNonNull(mapper, ERROR_MAPPER_NULL);
2737         return createIntegerBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2738     }
2739 
2740     /**
2741      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2742      *
2743      @param items    the observable list of elements.
2744      @param supplier a {@code Supplier} whose result is returned if no value is present.
2745      @param mapper   a non-interfering, stateless function to apply to each element.
2746      @param reducer  an associative, non-interfering, stateless function for combining two values.
2747      *
2748      @return an integer binding
2749      */
2750     @Nonnull
2751     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final Function<? super T, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2752         requireNonNull(items, ERROR_ITEMS_NULL);
2753         requireNonNull(reducer, ERROR_REDUCER_NULL);
2754         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2755         requireNonNull(mapper, ERROR_MAPPER_NULL);
2756         return createIntegerBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2757     }
2758 
2759     /**
2760      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2761      *
2762      @param items        the observable list of elements.
2763      @param defaultValue the value to be returned if there is no value present, may be null.
2764      @param mapper       a non-interfering, stateless function to apply to each element.
2765      @param reducer      an associative, non-interfering, stateless function for combining two values.
2766      *
2767      @return an integer binding
2768      */
2769     @Nonnull
2770     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Integer defaultValue, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2771         requireNonNull(reducer, ERROR_REDUCER_NULL);
2772         requireNonNull(mapper, ERROR_MAPPER_NULL);
2773         return createIntegerBinding(() -> {
2774             BinaryOperator<Integer> reducerValue = reducer.getValue();
2775             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2776             final Function<? super T, Integer> mapperValue = mapper.getValue();
2777             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2778             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2779         }, items, reducer, mapper);
2780     }
2781 
2782     /**
2783      * Returns an integer binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2784      *
2785      @param items    the observable list of elements.
2786      @param supplier a {@code Supplier} whose result is returned if no value is present.
2787      @param mapper   a non-interfering, stateless function to apply to each element.
2788      @param reducer  an associative, non-interfering, stateless function for combining two values.
2789      *
2790      @return an integer binding
2791      */
2792     @Nonnull
2793     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2794         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2795         requireNonNull(reducer, ERROR_REDUCER_NULL);
2796         requireNonNull(mapper, ERROR_MAPPER_NULL);
2797         return createIntegerBinding(() -> {
2798             BinaryOperator<Integer> reducerValue = reducer.getValue();
2799             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2800             final Function<? super T, Integer> mapperValue = mapper.getValue();
2801             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2802             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2803         }, items, reducer, mapper);
2804     }
2805 
2806     /**
2807      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2808      *
2809      @param items        the observable set of elements.
2810      @param defaultValue the value to be returned if there is no value present, may be null.
2811      @param mapper       a non-interfering, stateless function to apply to each element.
2812      @param reducer      an associative, non-interfering, stateless function for combining two values.
2813      *
2814      @return an integer binding
2815      */
2816     @Nonnull
2817     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Integer defaultValue, @Nonnull final Function<? super T, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2818         requireNonNull(items, ERROR_ITEMS_NULL);
2819         requireNonNull(reducer, ERROR_REDUCER_NULL);
2820         return createIntegerBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2821     }
2822 
2823     /**
2824      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2825      *
2826      @param items    the observable set of elements.
2827      @param supplier a {@code Supplier} whose result is returned if no value is present.
2828      @param mapper   a non-interfering, stateless function to apply to each element.
2829      @param reducer  an associative, non-interfering, stateless function for combining two values.
2830      *
2831      @return an integer binding
2832      */
2833     @Nonnull
2834     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final Function<? super T, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2835         requireNonNull(items, ERROR_ITEMS_NULL);
2836         requireNonNull(reducer, ERROR_REDUCER_NULL);
2837         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2838         requireNonNull(mapper, ERROR_MAPPER_NULL);
2839         return createIntegerBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2840     }
2841 
2842     /**
2843      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2844      *
2845      @param items        the observable set of elements.
2846      @param defaultValue the value to be returned if there is no value present, may be null.
2847      @param mapper       a non-interfering, stateless function to apply to each element.
2848      @param reducer      an associative, non-interfering, stateless function for combining two values.
2849      *
2850      @return an integer binding
2851      */
2852     @Nonnull
2853     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Integer defaultValue, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2854         requireNonNull(reducer, ERROR_REDUCER_NULL);
2855         requireNonNull(mapper, ERROR_MAPPER_NULL);
2856         return createIntegerBinding(() -> {
2857             BinaryOperator<Integer> reducerValue = reducer.getValue();
2858             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2859             final Function<? super T, Integer> mapperValue = mapper.getValue();
2860             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2861             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2862         }, items, reducer, mapper);
2863     }
2864 
2865     /**
2866      * Returns an integer binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
2867      *
2868      @param items    the observable set of elements.
2869      @param supplier a {@code Supplier} whose result is returned if no value is present.
2870      @param mapper   a non-interfering, stateless function to apply to each element.
2871      @param reducer  an associative, non-interfering, stateless function for combining two values.
2872      *
2873      @return an integer binding
2874      */
2875     @Nonnull
2876     public static <T> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final ObservableValue<Function<? super T, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2877         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2878         requireNonNull(reducer, ERROR_REDUCER_NULL);
2879         requireNonNull(mapper, ERROR_MAPPER_NULL);
2880         return createIntegerBinding(() -> {
2881             BinaryOperator<Integer> reducerValue = reducer.getValue();
2882             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2883             final Function<? super T, Integer> mapperValue = mapper.getValue();
2884             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2885             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2886         }, items, reducer, mapper);
2887     }
2888 
2889     /**
2890      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2891      *
2892      @param items        the observable map.
2893      @param defaultValue the value to be returned if there is no value present, may be null.
2894      @param mapper       a non-interfering, stateless function to apply to each value.
2895      @param reducer      an associative, non-interfering, stateless function for combining two values.
2896      *
2897      @return an integer binding
2898      */
2899     @Nonnull
2900     public static <K, V> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final Integer defaultValue, @Nonnull final Function<? super V, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2901         requireNonNull(items, ERROR_ITEMS_NULL);
2902         requireNonNull(reducer, ERROR_REDUCER_NULL);
2903         requireNonNull(mapper, ERROR_MAPPER_NULL);
2904         return createIntegerBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2905     }
2906 
2907     /**
2908      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2909      *
2910      @param items    the observable map.
2911      @param supplier a {@code Supplier} whose result is returned if no value is present.
2912      @param mapper   a non-interfering, stateless function to apply to each value.
2913      @param reducer  an associative, non-interfering, stateless function for combining two values.
2914      *
2915      @return an integer binding
2916      */
2917     @Nonnull
2918     public static <K, V> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final Function<? super V, Integer> mapper, @Nonnull final BinaryOperator<Integer> reducer) {
2919         requireNonNull(items, ERROR_ITEMS_NULL);
2920         requireNonNull(reducer, ERROR_REDUCER_NULL);
2921         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2922         requireNonNull(mapper, ERROR_MAPPER_NULL);
2923         return createIntegerBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
2924     }
2925 
2926     /**
2927      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2928      *
2929      @param items        the observable map.
2930      @param defaultValue the value to be returned if there is no value present, may be null.
2931      @param mapper       a non-interfering, stateless function to apply to each value.
2932      @param reducer      an associative, non-interfering, stateless function for combining two values.
2933      *
2934      @return an integer binding
2935      */
2936     @Nonnull
2937     public static <K, V> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final Integer defaultValue, @Nonnull final ObservableValue<Function<? super V, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2938         requireNonNull(reducer, ERROR_REDUCER_NULL);
2939         requireNonNull(mapper, ERROR_MAPPER_NULL);
2940         return createIntegerBinding(() -> {
2941             BinaryOperator<Integer> reducerValue = reducer.getValue();
2942             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2943             final Function<? super V, Integer> mapperValue = mapper.getValue();
2944             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2945             return items.values().stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
2946         }, items, reducer, mapper);
2947     }
2948 
2949     /**
2950      * Returns an integer binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
2951      *
2952      @param items    the observable map.
2953      @param supplier a {@code Supplier} whose result is returned if no value is present.
2954      @param mapper   a non-interfering, stateless function to apply to each value.
2955      @param reducer  an associative, non-interfering, stateless function for combining two values.
2956      *
2957      @return an integer binding
2958      */
2959     @Nonnull
2960     public static <K, V> IntegerBinding mapToIntegerThenReduce(@Nonnull final ObservableMap<K, V> items, @Nonnull final Supplier<Integer> supplier, @Nonnull final ObservableValue<Function<? super V, Integer>> mapper, @Nonnull final ObservableValue<BinaryOperator<Integer>> reducer) {
2961         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
2962         requireNonNull(reducer, ERROR_REDUCER_NULL);
2963         requireNonNull(mapper, ERROR_MAPPER_NULL);
2964         return createIntegerBinding(() -> {
2965             BinaryOperator<Integer> reducerValue = reducer.getValue();
2966             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
2967             final Function<? super V, Integer> mapperValue = mapper.getValue();
2968             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
2969             return items.values().stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
2970         }, items, reducer, mapper);
2971     }
2972 
2973     /**
2974      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2975      *
2976      @param items        the observable list of elements.
2977      @param defaultValue the value to be returned if there is no value present, may be null.
2978      @param mapper       a non-interfering, stateless function to apply to each element.
2979      @param reducer      an associative, non-interfering, stateless function for combining two values.
2980      *
2981      @return a long binding
2982      */
2983     @Nonnull
2984     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Long defaultValue, @Nonnull final Function<? super T, Long> mapper, @Nonnull final BinaryOperator<Long> reducer) {
2985         requireNonNull(items, ERROR_ITEMS_NULL);
2986         requireNonNull(reducer, ERROR_REDUCER_NULL);
2987         requireNonNull(mapper, ERROR_MAPPER_NULL);
2988         return createLongBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
2989     }
2990 
2991     /**
2992      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
2993      *
2994      @param items    the observable list of elements.
2995      @param supplier a {@code Supplier} whose result is returned if no value is present.
2996      @param mapper   a non-interfering, stateless function to apply to each element.
2997      @param reducer  an associative, non-interfering, stateless function for combining two values.
2998      *
2999      @return a long binding
3000      */
3001     @Nonnull
3002     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Long> supplier, @Nonnull final Function<? super T, Long> mapper, @Nonnull final BinaryOperator<Long> reducer) {
3003         requireNonNull(items, ERROR_ITEMS_NULL);
3004         requireNonNull(reducer, ERROR_REDUCER_NULL);
3005         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
3006         requireNonNull(mapper, ERROR_MAPPER_NULL);
3007         return createLongBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
3008     }
3009 
3010     /**
3011      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
3012      *
3013      @param items        the observable list of elements.
3014      @param defaultValue the value to be returned if there is no value present, may be null.
3015      @param mapper       a non-interfering, stateless function to apply to each element.
3016      @param reducer      an associative, non-interfering, stateless function for combining two values.
3017      *
3018      @return a long binding
3019      */
3020     @Nonnull
3021     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableList<T> items, @Nullable final Long defaultValue, @Nonnull final ObservableValue<Function<? super T, Long>> mapper, @Nonnull final ObservableValue<BinaryOperator<Long>> reducer) {
3022         requireNonNull(reducer, ERROR_REDUCER_NULL);
3023         requireNonNull(mapper, ERROR_MAPPER_NULL);
3024         return createLongBinding(() -> {
3025             BinaryOperator<Long> reducerValue = reducer.getValue();
3026             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
3027             final Function<? super T, Long> mapperValue = mapper.getValue();
3028             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
3029             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
3030         }, items, reducer, mapper);
3031     }
3032 
3033     /**
3034      * Returns a long binding whose value is the reduction of all elements in the list. The mapper function is applied to each element before reduction.
3035      *
3036      @param items    the observable list of elements.
3037      @param supplier a {@code Supplier} whose result is returned if no value is present.
3038      @param mapper   a non-interfering, stateless function to apply to each element.
3039      @param reducer  an associative, non-interfering, stateless function for combining two values.
3040      *
3041      @return a long binding
3042      */
3043     @Nonnull
3044     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableList<T> items, @Nonnull final Supplier<Long> supplier, @Nonnull final ObservableValue<Function<? super T, Long>> mapper, @Nonnull final ObservableValue<BinaryOperator<Long>> reducer) {
3045         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
3046         requireNonNull(reducer, ERROR_REDUCER_NULL);
3047         requireNonNull(mapper, ERROR_MAPPER_NULL);
3048         return createLongBinding(() -> {
3049             BinaryOperator<Long> reducerValue = reducer.getValue();
3050             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
3051             final Function<? super T, Long> mapperValue = mapper.getValue();
3052             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
3053             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
3054         }, items, reducer, mapper);
3055     }
3056 
3057     /**
3058      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
3059      *
3060      @param items        the observable set of elements.
3061      @param defaultValue the value to be returned if there is no value present, may be null.
3062      @param mapper       a non-interfering, stateless function to apply to each element.
3063      @param reducer      an associative, non-interfering, stateless function for combining two values.
3064      *
3065      @return a long binding
3066      */
3067     @Nonnull
3068     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Long defaultValue, @Nonnull final Function<? super T, Long> mapper, @Nonnull final BinaryOperator<Long> reducer) {
3069         requireNonNull(items, ERROR_ITEMS_NULL);
3070         requireNonNull(reducer, ERROR_REDUCER_NULL);
3071         return createLongBinding(() -> items.stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
3072     }
3073 
3074     /**
3075      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
3076      *
3077      @param items    the observable set of elements.
3078      @param supplier a {@code Supplier} whose result is returned if no value is present.
3079      @param mapper   a non-interfering, stateless function to apply to each element.
3080      @param reducer  an associative, non-interfering, stateless function for combining two values.
3081      *
3082      @return a long binding
3083      */
3084     @Nonnull
3085     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Long> supplier, @Nonnull final Function<? super T, Long> mapper, @Nonnull final BinaryOperator<Long> reducer) {
3086         requireNonNull(items, ERROR_ITEMS_NULL);
3087         requireNonNull(reducer, ERROR_REDUCER_NULL);
3088         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
3089         requireNonNull(mapper, ERROR_MAPPER_NULL);
3090         return createLongBinding(() -> items.stream().map(mapper).reduce(reducer).orElseGet(supplier), items);
3091     }
3092 
3093     /**
3094      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
3095      *
3096      @param items        the observable set of elements.
3097      @param defaultValue the value to be returned if there is no value present, may be null.
3098      @param mapper       a non-interfering, stateless function to apply to each element.
3099      @param reducer      an associative, non-interfering, stateless function for combining two values.
3100      *
3101      @return a long binding
3102      */
3103     @Nonnull
3104     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableSet<T> items, @Nullable final Long defaultValue, @Nonnull final ObservableValue<Function<? super T, Long>> mapper, @Nonnull final ObservableValue<BinaryOperator<Long>> reducer) {
3105         requireNonNull(reducer, ERROR_REDUCER_NULL);
3106         requireNonNull(mapper, ERROR_MAPPER_NULL);
3107         return createLongBinding(() -> {
3108             BinaryOperator<Long> reducerValue = reducer.getValue();
3109             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
3110             final Function<? super T, Long> mapperValue = mapper.getValue();
3111             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
3112             return items.stream().map(mapperValue).reduce(reducerValue).orElse(defaultValue);
3113         }, items, reducer, mapper);
3114     }
3115 
3116     /**
3117      * Returns a long binding whose value is the reduction of all elements in the set. The mapper function is applied to each element before reduction.
3118      *
3119      @param items    the observable set of elements.
3120      @param supplier a {@code Supplier} whose result is returned if no value is present.
3121      @param mapper   a non-interfering, stateless function to apply to each element.
3122      @param reducer  an associative, non-interfering, stateless function for combining two values.
3123      *
3124      @return a long binding
3125      */
3126     @Nonnull
3127     public static <T> LongBinding mapToLongThenReduce(@Nonnull final ObservableSet<T> items, @Nonnull final Supplier<Long> supplier, @Nonnull final ObservableValue<Function<? super T, Long>> mapper, @Nonnull final ObservableValue<BinaryOperator<Long>> reducer) {
3128         requireNonNull(supplier, ERROR_SUPPLIER_NULL);
3129         requireNonNull(reducer, ERROR_REDUCER_NULL);
3130         requireNonNull(mapper, ERROR_MAPPER_NULL);
3131         return createLongBinding(() -> {
3132             BinaryOperator<Long> reducerValue = reducer.getValue();
3133             requireNonNull(reducerValue, ERROR_REDUCER_NULL);
3134             final Function<? super T, Long> mapperValue = mapper.getValue();
3135             requireNonNull(mapperValue, ERROR_MAPPER_NULL);
3136             return items.stream().map(mapperValue).reduce(reducerValue).orElseGet(supplier);
3137         }, items, reducer, mapper);
3138     }
3139 
3140     /**
3141      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
3142      *
3143      @param items        the observable map.
3144      @param defaultValue the value to be returned if there is no value present, may be null.
3145      @param mapper       a non-interfering, stateless function to apply to each value.
3146      @param reducer      an associative, non-interfering, stateless function for combining two values.
3147      *
3148      @return a long binding
3149      */
3150     @Nonnull
3151     public static <K, V> LongBinding mapToLongThenReduce(@Nonnull final ObservableMap<K, V> items, @Nullable final Long defaultValue, @Nonnull final Function<? super V, Long> mapper, @Nonnull final BinaryOperator<Long> reducer) {
3152         requireNonNull(items, ERROR_ITEMS_NULL);
3153         requireNonNull(reducer, ERROR_REDUCER_NULL);
3154         requireNonNull(mapper, ERROR_MAPPER_NULL);
3155         return createLongBinding(() -> items.values().stream().map(mapper).reduce(reducer).orElse(defaultValue), items);
3156     }
3157 
3158     /**
3159      * Returns a long binding whose value is the reduction of all values in the map. The mapper function is applied to each value before reduction.
3160      *
3161      @param items    the observable map.
3162      @param supplier a {@code Supplier} whose result is returned if no value is present.
3163      @param mapper   a non-interfering, stateless function