Back to index...

	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 org.apache.commons.collections4.multimap;

	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import java.util.ListIterator;
	import java.util.Map;

	import org.apache.commons.collections4.ListUtils;
	import org.apache.commons.collections4.ListValuedMap;

	/**
	* Abstract implementation of the {@link ListValuedMap} interface to simplify
	* the creation of subclass implementations.
	* <p>
	* Subclasses specify a Map implementation to use as the internal storage and
	* the List implementation to use as values.
	* </p>
	*
	* @param <K> the type of the keys in this map
	* @param <V> the type of the values in this map
	* @since 4.1
	*/
	public abstract class AbstractListValuedMap<K, V> extends AbstractMultiValuedMap<K, V>
	implements ListValuedMap<K, V> {

	/**
	* Constructor needed for subclass serialisation.
	*/
	protected AbstractListValuedMap() {
	super();
	}

	/**
	* A constructor that wraps, not copies
	*
	* @param map the map to wrap, must not be null
	* @throws NullPointerException if the map is null
	*/
	protected AbstractListValuedMap(final Map<K, ? extends List<V>> map) {
	super(map);
	}

	// -----------------------------------------------------------------------
	@Override
	@SuppressWarnings("unchecked")
	protected Map<K, List<V>> getMap() {
	return (Map<K, List<V>>) super.getMap();
	}

	/**
	* Creates a new value collection using the provided factory.
	* @return a new list
	*/
	@Override
	protected abstract List<V> createCollection();

	// -----------------------------------------------------------------------
	/**
	* Gets the list of values associated with the specified key. This would
	* return an empty list in case the mapping is not present
	*
	* @param key the key to retrieve
	* @return the {@code List} of values, will return an empty {@link List} for no mapping
	*/
	@Override
	public List<V> get(final K key) {
	return wrappedCollection(key);
	}

	@Override
	List<V> wrappedCollection(final K key) {
	return new WrappedList(key);
	}

	/**
	* Removes all values associated with the specified key.
	* <p>
	* A subsequent <code>get(Object)</code> would return an empty list.
	*
	* @param key the key to remove values from
	* @return the <code>List</code> of values removed, will return an empty,
	* unmodifiable list for no mapping found.
	*/
	@Override
	public List<V> remove(final Object key) {
	return ListUtils.emptyIfNull(getMap().remove(key));
	}

	// -----------------------------------------------------------------------
	/**
	* Wrapped list to handle add and remove on the list returned by get(object)
	*/
	private class WrappedList extends WrappedCollection implements List<V> {

	public WrappedList(final K key) {
	super(key);
	}

	@Override
	protected List<V> getMapping() {
	return getMap().get(key);
	}

	@Override
	public void add(final int index, final V value) {
	List<V> list = getMapping();
	if (list == null) {
	list = createCollection();
	getMap().put(key, list);
	}
	list.add(index, value);
	}

	@Override
	public boolean addAll(final int index, final Collection<? extends V> c) {
	List<V> list = getMapping();
	if (list == null) {
	list = createCollection();
	final boolean changed = list.addAll(index, c);
	if (changed) {
	getMap().put(key, list);
	}
	return changed;
	}
	return list.addAll(index, c);
	}

	@Override
	public V get(final int index) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	return list.get(index);
	}

	@Override
	public int indexOf(final Object o) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	return list.indexOf(o);
	}

	@Override
	public int lastIndexOf(final Object o) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	return list.lastIndexOf(o);
	}

	@Override
	public ListIterator<V> listIterator() {
	return new ValuesListIterator(key);
	}

	@Override
	public ListIterator<V> listIterator(final int index) {
	return new ValuesListIterator(key, index);
	}

	@Override
	public V remove(final int index) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	final V value = list.remove(index);
	if (list.isEmpty()) {
	AbstractListValuedMap.this.remove(key);
	}
	return value;
	}

	@Override
	public V set(final int index, final V value) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	return list.set(index, value);
	}

	@Override
	public List<V> subList(final int fromIndex, final int toIndex) {
	final List<V> list = ListUtils.emptyIfNull(getMapping());
	return list.subList(fromIndex, toIndex);
	}

	@Override
	public boolean equals(final Object other) {
	final List<V> list = getMapping();
	if (list == null) {
	return Collections.emptyList().equals(other);
	}
	if (!(other instanceof List)) {
	return false;
	}
	final List<?> otherList = (List<?>) other;
	return ListUtils.isEqualList(list, otherList);
	}

	@Override
	public int hashCode() {
	final List<V> list = getMapping();
	return ListUtils.hashCodeForList(list);
	}

	}

	/** Values ListIterator */
	private class ValuesListIterator implements ListIterator<V> {

	private final K key;
	private List<V> values;
	private ListIterator<V> iterator;

	public ValuesListIterator(final K key) {
	this.key = key;
	this.values = ListUtils.emptyIfNull(getMap().get(key));
	this.iterator = values.listIterator();
	}

	public ValuesListIterator(final K key, final int index) {
	this.key = key;
	this.values = ListUtils.emptyIfNull(getMap().get(key));
	this.iterator = values.listIterator(index);
	}

	@Override
	public void add(final V value) {
	if (getMap().get(key) == null) {
	final List<V> list = createCollection();
	getMap().put(key, list);
	this.values = list;
	this.iterator = list.listIterator();
	}
	this.iterator.add(value);
	}

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

	@Override
	public boolean hasPrevious() {
	return iterator.hasPrevious();
	}

	@Override
	public V next() {
	return iterator.next();
	}

	@Override
	public int nextIndex() {
	return iterator.nextIndex();
	}

	@Override
	public V previous() {
	return iterator.previous();
	}

	@Override
	public int previousIndex() {
	return iterator.previousIndex();
	}

	@Override
	public void remove() {
	iterator.remove();
	if (values.isEmpty()) {
	getMap().remove(key);
	}
	}

	@Override
	public void set(final V value) {
	iterator.set(value);
	}

	}

	}

Back to index...