net.intelie.pipes.util.MergedMap Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of pipes-api Show documentation
Intelie Pipes' API classes and interfaces
There is a newer version: 0.25.5
package net.intelie.pipes.util;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

public class MergedMap extends AbstractMap implements Serializable {
    private static final long serialVersionUID = 1L;

    private final HashMap cache = new HashMap<>();
    private final List> maps;
    private Set keys = null;

    public MergedMap(List> maps) {
        this.maps = maps;
    }

    @Override
    public Set> entrySet() {
        return new EntrySet();
    }

    @Override
    public Set keySet() {
        if (keys == null) {
            Set set = maps.stream().
                    flatMap(x -> x.keySet().stream())
                    .collect(Collectors.toCollection(LinkedHashSet::new));
            keys = Collections.unmodifiableSet(set);
        }
        return keys;
    }

    @Override
    public V get(Object key) {
        V value = cache.get(key);
        if (value != null || cache.containsKey(key))
            return value;

        for (int i = maps.size(); --i >= 0; ) {
            Map map = maps.get(i);
            value = map.get(key);
            if (value != null || map.containsKey(key)) {
                cache.put(key, value);
                return value;
            }
        }
        return null;
    }


    @Override
    public boolean containsKey(Object key) {
        if (cache.containsKey(key))
            return true;

        for (int i = maps.size(); --i >= 0; ) {
            Map map = maps.get(i);
            if (map.containsKey(key)) {
                cache.put(key, map.get(key));
                return true;
            }
        }


        return false;
    }

    private class EntrySet extends AbstractSet> {
        @Override
        public Iterator> iterator() {
            return new EntryIterator();
        }

        @Override
        public boolean contains(Object o) {
            if (!(o instanceof Entry)) return false;
            Object value = get(((Entry) o).getKey());
            return Objects.equals(value, ((Entry) o).getValue());
        }

        @Override
        public int size() {
            return keySet().size();
        }
    }

    private class EntryIterator implements Iterator> {
        private final Iterator it = keySet().iterator();

        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public Entry next() {
            K key = it.next();
            return new SimpleImmutableEntry<>(key, get(key));
        }
    }
}