com.groupon.lex.metrics.resolver.NameBoundResolverSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of monsoon-collector-base Show documentation
The newest version!
package com.groupon.lex.metrics.resolver;

import com.groupon.lex.metrics.lib.Any2;
import com.groupon.lex.metrics.lib.Any3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import static java.util.Collections.unmodifiableList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.Value;
import static java.util.Objects.requireNonNull;
import lombok.NonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;

@Value
public class NameBoundResolverSet implements NameBoundResolver {
    private final List nameResolvers;

    public NameBoundResolverSet(@NonNull Collection nameResolvers) {
        nameResolvers.stream().forEach((nr) -> requireNonNull(nr, "null name resolver"));
        this.nameResolvers = unmodifiableList(new ArrayList<>(nameResolvers));
    }

    public NameBoundResolverSet(NameBoundResolver... nameResolvers) {
        this(Arrays.asList(nameResolvers));
    }

    @Override
    public Stream resolve() throws Exception {
        final List> sets = new ArrayList<>(nameResolvers.size());
        for (NameBoundResolver nr : nameResolvers)
            sets.add(nr.resolve().collect(Collectors.toList()));

        return cartesianProduct(sets);
    }

    @Override
    public Stream> getKeys() {
        return nameResolvers.stream()
                .flatMap(NameBoundResolver::getKeys);
    }

    @Override
    public String configString() {
        if (isEmpty()) return "{}";
        return nameResolvers.stream()
                .map(NameBoundResolver::configString)
                .map(s -> "    " + s) // Indentation
                .collect(Collectors.joining(",\n", "{\n", "\n}"));
    }

    @Override
    public boolean isEmpty() {
        return nameResolvers.stream()
                .allMatch(NameBoundResolver::isEmpty);
    }

    private static Stream cartesianProduct(Stream in, Iterable> sets) {
        final Iterator> setsIter = sets.iterator();

        while (setsIter.hasNext()) {
            final Collection head = setsIter.next();

            in = in
                    .flatMap(in_map -> {
                        return head.stream()
                                .map(headMap -> {
                                    Map, Any3> out_map = new HashMap<>();
                                    out_map.putAll(in_map.getRawMap());
                                    out_map.putAll(headMap.getRawMap());
                                    return new NamedResolverMap(out_map);
                                });
                    });
        }
        return in;
    }

    private static Stream cartesianProduct(Iterable> sets) {
        return cartesianProduct(Stream.of(NamedResolverMap.EMPTY), sets);
    }

    @Override
    public void close() throws Exception {
        Exception thrown = null;
        for (NameBoundResolver resolver : nameResolvers) {
            try {
                resolver.close();
            } catch (Exception ex) {
                if (thrown == null)
                    thrown = ex;
                else
                    thrown.addSuppressed(ex);
            }
        }
        if (thrown != null) throw thrown;
    }
}