jp.skypencil.guava.stream.GuavaCollectors Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of helper Show documentation
Helper classes to help Java8 to collaborate with Guava
There is a newer version: 1.2.0
package jp.skypencil.guava.stream;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

import com.google.common.collect.BiMap;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.ImmutableMultiset;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableTable;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import com.google.common.collect.Table;

public class GuavaCollectors {
    private static final  BinaryOperator throwingMerger() {
        return (value, another) -> {
            throw new IllegalStateException(String.format("Duplicated value %s", value));
        };
    };

    public static  Collector> toImmutableList() {
        return new Collector, ImmutableList>(){

            @Override
            public Supplier> supplier() {
                return ImmutableList::builder;
            }

            @Override
            public BiConsumer, T> accumulator() {
                return (builder, value) -> builder.add(value);
            }

            @Override
            public BinaryOperator> combiner() {
                return (builder, another) -> builder.addAll(another.build());
            }

            @Override
            public Function, ImmutableList> finisher() {
                return ImmutableList.Builder::build;
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toImmutableSet() {
        return new Collector, ImmutableSet>(){
            @Override
            public Supplier> supplier() {
                return ImmutableSet::builder;
            }

            @Override
            public BiConsumer, T> accumulator() {
                return (builder, value) -> builder.add(value);
            }

            @Override
            public BinaryOperator> combiner() {
                return (builder, another) -> builder.addAll(another.build());
            }

            @Override
            public Function, ImmutableSet> finisher() {
                return ImmutableSet.Builder::build;
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toImmutableMap(
            Function keyMapper,
            Function valueMapper) {
        return toImmutableMap(keyMapper, valueMapper, throwingMerger());
    }

    public static  Collector> toImmutableMap(
            Function keyMapper,
            Function valueMapper,
            BinaryOperator mergeFunction) {

        return new Collector, ImmutableMap>(){
            @Override
            public Supplier> supplier() {
                return HashMap::new;
            }

            @Override
            public BiConsumer, T> accumulator() {
                return (map, entry) -> {
                    K key = keyMapper.apply(entry);
                    U value = valueMapper.apply(entry);
                    map.merge(key, value, mergeFunction);
                };
            }

            @Override
            public BinaryOperator> combiner() {
                return (map, another) -> {
                    another.forEach((key, value) -> {
                        map.merge(key, value, mergeFunction);
                    });
                    return map;
                };
            }

            @Override
            public Function, ImmutableMap> finisher() {
                return (map) -> {
                    ImmutableMap.Builder builder = ImmutableMap.builder();
                    return builder.putAll(map).build();
                };
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toTable(
            Function rowMapper,
            Function columnMapper,
            Function valueMapper) {
        return toTable(rowMapper, columnMapper, valueMapper, throwingMerger());
    }

    public static  Collector> toTable(
            Function rowMapper,
            Function columnMapper,
            Function valueMapper,
            BinaryOperator mergeFunction) {


        return new TableCollector>(
                rowMapper, columnMapper, valueMapper, mergeFunction) {
            @Override
            public Function, Table> finisher() {
                return Function.identity();
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.IDENTITY;
            }
        };
    }

    public static  Collector> toImmutableTable(
            Function rowMapper,
            Function columnMapper,
            Function valueMapper) {
        return toImmutableTable(rowMapper, columnMapper, valueMapper, throwingMerger());
    }

    public static  Collector> toImmutableTable(
            Function rowMapper,
            Function columnMapper,
            Function valueMapper,
            BinaryOperator mergeFunction) {

        return new TableCollector>(
                rowMapper, columnMapper, valueMapper, mergeFunction) {
            @Override
            public Function, ImmutableTable> finisher() {
                return (table) -> {
                    ImmutableTable.Builder builder = ImmutableTable
                            .builder();
                    return builder.putAll(table).build();
                };
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toBiMap(
            Function keyMapper,
            Function valueMapper) {
        return toBiMap(keyMapper, valueMapper, throwingMerger());
    }

    public static  Collector> toBiMap(
            Function keyMapper,
            Function valueMapper,
            BinaryOperator mergeFunction) {
        return new BiMapCollector>(keyMapper, valueMapper,
                mergeFunction) {
            @Override
            public Function, BiMap> finisher() {
                return Function.identity();
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.IDENTITY;
            }
        };
    }

    public static  Collector> toImmutableBiMap(
            Function keyMapper,
            Function valueMapper) {
        return toImmutableBiMap(keyMapper, valueMapper, throwingMerger());
    }

    public static  Collector> toImmutableBiMap(
            Function keyMapper,
            Function valueMapper,
            BinaryOperator mergeFunction) {
        return new BiMapCollector>(keyMapper,
                valueMapper, mergeFunction) {
            @Override
            public Function, ImmutableBiMap> finisher() {
                return map -> {
                    ImmutableBiMap.Builder builder = ImmutableBiMap
                            .builder();
                    return builder.putAll(map).build();
                };
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toMultimap(
            Function keyMapper,
            Function valueMapper) {
        return new MultimapCollector>(keyMapper,
                valueMapper) {
            @Override
            public Function, Multimap> finisher() {
                return Function.identity();
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.IDENTITY;
            }
        };
    }

    public static  Collector> toImmutableMultimap(
            Function keyMapper,
            Function valueMapper) {
        return new MultimapCollector>(
                keyMapper, valueMapper) {
            @Override
            public Function, ImmutableMultimap> finisher() {
                return (map) -> {
                    ImmutableMultimap.Builder builder = ImmutableMultimap
                            .builder();
                    return builder.putAll(map).build();
                };
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    public static  Collector> toMultiset() {
        return new MultisetCollector>() {
            @Override
            public Function, Multiset> finisher() {
                return Function.identity();
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.IDENTITY;
            }
        };
    }

    public static  Collector> toImmutableMultiset() {
        return new MultisetCollector>() {
            @Override
            public Function, ImmutableMultiset> finisher() {
                return (set) -> {
                    ImmutableMultiset.Builder builder = ImmutableMultiset.builder();
                    return builder.addAll(set).build();
                };
            }

            @Override
            public Set characteristics() {
                return CharacteristicSets.EMPTY;
            }
        };
    }

    // TODO groupingBy
}