io.github.mike10004.harreplay.vhsimpl.NameValuePairList Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of har-replay-vhs Show documentation
The newest version!
package io.github.mike10004.harreplay.vhsimpl;

import com.google.common.collect.ImmutableList;

import javax.annotation.Nullable;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.Objects.requireNonNull;

public class NameValuePairList {

    private final ImmutableList pairs;
    private final Function nameGetter;
    private final Function valueGetter;
    private final BiPredicate nameMatcher;

    public NameValuePairList(Iterable pairs, Function nameGetter, Function valueGetter, BiPredicate nameMatcher) {
        this.pairs = ImmutableList.copyOf(pairs);
        this.nameGetter = requireNonNull(nameGetter);
        this.valueGetter = requireNonNull(valueGetter);
        this.nameMatcher = requireNonNull(nameMatcher);
    }

    public static  NameValuePairList empty() {
        return (NameValuePairList) StringMapEntryList.empty();
    }

    private static final BiPredicate CASE_INSENSITIVE_MATCHER = String::equalsIgnoreCase;
    private static final BiPredicate CASE_SENSITIVE_MATCHER = String::equals;

    protected static BiPredicate caseSensitiveMatcher() {
        return CASE_SENSITIVE_MATCHER;
    }

    protected static BiPredicate caseInsensitiveMatcher() {
        return CASE_INSENSITIVE_MATCHER;
    }

    @Nullable
    public String getFirstValue(String name) {
        requireNonNull(name, "name");
        return pairs.stream()
                .filter(p -> nameMatcher.test(name, nameGetter.apply(p)))
                .map(valueGetter::apply)
                .map(Optional::ofNullable).findFirst().flatMap(Function.identity())
                .orElse(null);
    }

    public Stream streamValues(String name) {
        requireNonNull(name, "name");
        return pairs.stream()
                .filter(p -> nameMatcher.test(name, nameGetter.apply(p)))
                .map(valueGetter::apply);
    }

    public ImmutableList listValues(String name) {
        return streamValues(name).collect(ImmutableList.toImmutableList());
    }

    public static  NameValuePairList caseSensitive(Iterable pairs, Function nameGetter, Function valueGetter) {
        return new NameValuePairList<>(pairs, nameGetter, valueGetter, CASE_SENSITIVE_MATCHER);
    }

    public static  NameValuePairList caseInsensitive(Iterable pairs, Function nameGetter, Function valueGetter) {
        return new NameValuePairList<>(pairs, nameGetter, valueGetter, CASE_INSENSITIVE_MATCHER);
    }

    public static class StringMapEntryList extends NameValuePairList> {

        private static final StringMapEntryList EMPTY = new StringMapEntryList(Collections.emptyList(), (x, y) -> false) {
            @Nullable
            @Override
            public final String getFirstValue(String name) {
                return null;
            }

            @Override
            public final Stream streamValues(String name) {
                return Stream.empty();
            }

            @Override
            public final ImmutableList listValues(String name) {
                return ImmutableList.of();
            }
        };

        public static StringMapEntryList empty() {
            return EMPTY;
        }

        public StringMapEntryList(Iterable> pairs, BiPredicate nameMatcher) {
            super(pairs, Map.Entry::getKey, Map.Entry::getValue, nameMatcher);
        }

        public static StringMapEntryList caseSensitive(Iterable> pairs) {
            return new StringMapEntryList(pairs, CASE_SENSITIVE_MATCHER);
        }

        public static StringMapEntryList caseInsensitive(Iterable> pairs) {
            return new StringMapEntryList(pairs, CASE_INSENSITIVE_MATCHER);
        }

    }
}