/* * Copyright (C) 2016 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.common.collect; import static com.google.common.base.Preconditions.checkNotNull; import com.google.common.annotations.GwtCompatible; import com.google.common.annotations.GwtIncompatible; import java.util.Comparator; import java.util.function.Function; import java.util.stream.Collector; /** Collectors utilities for {@code common.collect} internals. */ @GwtCompatible final class CollectCollectors { static Collector> toImmutableBiMap( Function keyFunction, Function valueFunction) { checkNotNull(keyFunction); checkNotNull(valueFunction); return Collector.of( ImmutableBiMap.Builder::new, (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableBiMap.Builder::combine, ImmutableBiMap.Builder::build, new Collector.Characteristics[0]); } private static final Collector> TO_IMMUTABLE_LIST = Collector.of( ImmutableList::builder, ImmutableList.Builder::add, ImmutableList.Builder::combine, ImmutableList.Builder::build); static Collector> toImmutableList() { return (Collector) TO_IMMUTABLE_LIST; } static Collector> toImmutableMap( Function keyFunction, Function valueFunction) { checkNotNull(keyFunction); checkNotNull(valueFunction); return Collector.of( ImmutableMap.Builder::new, (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableMap.Builder::combine, ImmutableMap.Builder::build); } private static final Collector> TO_IMMUTABLE_SET = Collector.of( ImmutableSet::builder, ImmutableSet.Builder::add, ImmutableSet.Builder::combine, ImmutableSet.Builder::build); static Collector> toImmutableSet() { return (Collector) TO_IMMUTABLE_SET; } static Collector> toImmutableSortedMap( Comparator comparator, Function keyFunction, Function valueFunction) { checkNotNull(comparator); checkNotNull(keyFunction); checkNotNull(valueFunction); /* * We will always fail if there are duplicate keys, and the keys are always sorted by * the Comparator, so the entries can come in in arbitrary order -- so we report UNORDERED. */ return Collector.of( () -> new ImmutableSortedMap.Builder(comparator), (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableSortedMap.Builder::combine, ImmutableSortedMap.Builder::build, Collector.Characteristics.UNORDERED); } static Collector> toImmutableSortedSet( Comparator comparator) { checkNotNull(comparator); return Collector.of( () -> new ImmutableSortedSet.Builder(comparator), ImmutableSortedSet.Builder::add, ImmutableSortedSet.Builder::combine, ImmutableSortedSet.Builder::build); } @GwtIncompatible private static final Collector, ?, ImmutableRangeSet> TO_IMMUTABLE_RANGE_SET = Collector.of( ImmutableRangeSet::builder, ImmutableRangeSet.Builder::add, ImmutableRangeSet.Builder::combine, ImmutableRangeSet.Builder::build); @GwtIncompatible static > Collector, ?, ImmutableRangeSet> toImmutableRangeSet() { return (Collector) TO_IMMUTABLE_RANGE_SET; } @GwtIncompatible static , V> Collector> toImmutableRangeMap( Function> keyFunction, Function valueFunction) { checkNotNull(keyFunction); checkNotNull(valueFunction); return Collector.of( ImmutableRangeMap::builder, (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)), ImmutableRangeMap.Builder::combine, ImmutableRangeMap.Builder::build); } }