pascal.taie.util.collection.MultiMapCollector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of tai-e Show documentation
An easy-to-learn/use static analysis framework for Java
The newest version!
/*
 * Tai-e: A Static Analysis Framework for Java
 *
 * Copyright (C) 2022 Tian Tan 
 * Copyright (C) 2022 Yue Li 
 *
 * This file is part of Tai-e.
 *
 * Tai-e is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *
 * Tai-e is distributed in the hope that it will be useful,but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
 * Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Tai-e. If not, see .
 */

package pascal.taie.util.collection;

import java.util.Collections;
import java.util.EnumSet;
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;

public class MultiMapCollector implements Collector, R> {

    private static final Set CH = Collections.unmodifiableSet(
            EnumSet.of(Characteristics.IDENTITY_FINISH));

    private final Supplier> supplier;

    private final Function keyMapper;

    private final Function valueMapper;

    private MultiMapCollector(Supplier> supplier,
                              Function keyMapper,
                              Function valueMapper) {
        this.supplier = supplier;
        this.keyMapper = keyMapper;
        this.valueMapper = valueMapper;
    }

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

    @Override
    public BiConsumer, T> accumulator() {
        return this::accumulate;
    }

    @Override
    public BinaryOperator> combiner() {
        return MultiMapCollector::combine;
    }

    @Override
    public Function, R> finisher() {
        return castingIdentity();
    }

    @Override
    public Set characteristics() {
        return CH;
    }

    private void accumulate(MultiMap m, T e) {
        m.put(keyMapper.apply(e), valueMapper.apply(e));
    }

    private static  MultiMap combine(MultiMap m1, MultiMap m2) {
        m1.putAll(m2);
        return m1;
    }

    @SuppressWarnings("unchecked")
    private static  Function castingIdentity() {
        return i -> (R) i;
    }

    public static >
    Collector get(Supplier> supplier,
                           Function keyMapper,
                           Function valueMapper) {
        return new MultiMapCollector<>(supplier, keyMapper, valueMapper);
    }

    public static >
    Collector get(Function keyMapper,
                           Function valueMapper) {
        return get(Maps::newMultiMap, keyMapper, valueMapper);
    }
}