org.xbib.helianthus.common.util.AbstractOptions Maven / Gradle / Ivy

Go to download
package org.xbib.helianthus.common.util;

import static java.util.Objects.requireNonNull;

import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

/**
 * A set of configuration options and their respective values.
 *
 * @see AbstractOption
 * @see AbstractOptionValue
 */
public abstract class AbstractOptions {

    protected Map, AbstractOptionValue, Object>> valueMap;

    @SuppressWarnings("varargs")
    @SafeVarargs
    protected > AbstractOptions(Function valueFilter, T... values) {
        requireNonNull(valueFilter, "valueFilter");
        requireNonNull(values, "values");
        valueMap = new IdentityHashMap<>();
        putAll(valueFilter, Stream.of(values));
    }

    protected > AbstractOptions(Function valueFilter,
                                                                    Iterable values) {
        requireNonNull(valueFilter, "valueFilter");
        requireNonNull(values, "values");
        valueMap = new IdentityHashMap<>();
        putAll(valueFilter, StreamSupport.stream(values.spliterator(), false));
    }

    @SuppressWarnings("varargs")
    @SafeVarargs
    protected > AbstractOptions(Function valueFilter,
                                                                    AbstractOptions baseOptions, T... values) {
        requireNonNull(baseOptions, "baseOptions");
        requireNonNull(valueFilter, "valueFilter");
        requireNonNull(values, "values");
        valueMap = new IdentityHashMap<>(baseOptions.valueMap);
        putAll(valueFilter, Stream.of(values));
    }

    protected > AbstractOptions(Function valueFilter,
                                                                    AbstractOptions baseOptions,
                                                                    Iterable values) {
        requireNonNull(baseOptions, "baseOptions");
        requireNonNull(valueFilter, "valueFilter");
        requireNonNull(values, "values");
        valueMap = new IdentityHashMap<>(baseOptions.valueMap);
        putAll(valueFilter, StreamSupport.stream(values.spliterator(), false));
    }

    protected > AbstractOptions(AbstractOptions baseOptions,
                                                                    AbstractOptions options) {
        requireNonNull(baseOptions, "baseOptions");
        requireNonNull(options, "options");
        valueMap = new IdentityHashMap<>(baseOptions.valueMap);
        valueMap.putAll(options.valueMap);
    }

    static String toString(Collection values) {
        return "OptionValues{" + values + '}';
    }

    @SuppressWarnings("unchecked")
    private > void putAll(Function valueFilter, Stream values) {
        values.map(valueFilter)
                .forEach(v -> valueMap.put((AbstractOption