com.github.paganini2008.devtools.collection.MultiValueMap Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of devtools-lang Show documentation
Java Core Basic Tools
There is a newer version: 2.0.5
package com.github.paganini2008.devtools.collection;

import java.io.Serializable;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 
 * MultiValueMap
 * 
 * @author Fred Feng
 * @version 1.0
 */
public class MultiValueMap extends AbstractMap> implements Map>, Serializable {

	private static final long serialVersionUID = 4293668328277273376L;
	private final Map> delegate;

	public MultiValueMap() {
		this(new HashMap>());
	}

	protected MultiValueMap(Map> delegate) {
		this.delegate = delegate;
	}

	public void clear() {
		delegate.clear();
	}

	public void clear(K key) {
		List list = delegate.get(key);
		if (list != null) {
			list.clear();
		}
	}

	public List remove(Object key) {
		return delegate.remove(key);
	}

	public V remove(K key, int index) {
		List list = delegate.get(key);
		return ListUtils.remove(list, index);
	}

	public V removeLast(K key) {
		List list = delegate.get(key);
		return ListUtils.removeLast(list);
	}

	public V removeFirst(K key) {
		List list = delegate.get(key);
		return ListUtils.removeFirst(list);
	}

	public V getFirst(K key) {
		List list = delegate.get(key);
		return ListUtils.getFirst(list);
	}

	public V getLast(K key) {
		List list = delegate.get(key);
		return ListUtils.getLast(list);
	}

	public V get(K key, int index) {
		List list = delegate.get(key);
		return ListUtils.get(list, index);
	}

	public List get(Object key) {
		return delegate.get(key);
	}

	public boolean containsKey(Object key) {
		return delegate.containsKey(key);
	}

	public void removeValue(K key, V value) {
		List list = delegate.get(key);
		if (list != null) {
			while (list.contains(value)) {
				list.remove(value);
			}
		}
	}

	public Set>> entrySet() {
		return delegate.entrySet();
	}

	public boolean containsValue(K key, V value) {
		List list = delegate.get(key);
		return list != null ? list.contains(value) : false;
	}

	public int size() {
		return delegate.size();
	}

	public Set keys() {
		return delegate.keySet();
	}

	public List put(K key, List value) {
		return delegate.put(key, value);
	}

	public void addAll(K key, Collection values) {
		List list = delegate.get(key);
		if (list == null) {
			delegate.putIfAbsent(key, createValueList());
			list = delegate.get(key);
		}
		list.addAll(values);
	}

	public V add(K key, V value) {
		List list = delegate.get(key);
		if (list == null) {
			delegate.putIfAbsent(key, createValueList());
			list = delegate.get(key);
		}
		list.add(value);
		return value;
	}

	protected List createValueList() {
		return new ArrayList();
	}

	public Map toSingleValueMap() {
		final Map map = new HashMap();
		for (Map.Entry> entry : delegate.entrySet()) {
			map.put(entry.getKey(), ListUtils.getFirst(entry.getValue()));
		}
		return map;
	}

	public static  Map> synchronizedMap() {
		return new MultiValueMap(new ConcurrentHashMap>()) {

			private static final long serialVersionUID = 1L;

			protected List createValueList() {
				return new CopyOnWriteArrayList();
			}
		};
	}

	public String toString() {
		return delegate.toString();
	}

}