All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.commons.collections4.map.CompositeMap Maven / Gradle / Ivy

There is a newer version: 5.0.70
Show newest version
/*
 * 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.map;

import java.io.Serializable;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections4.set.CompositeSet;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.collection.CompositeCollection;

/**
 * Decorates a map of other maps to provide a single unified view.
 * 

* Changes made to this map will actually be made on the decorated map. * Add and remove operations require the use of a pluggable strategy. If no * strategy is provided then add and remove are unsupported. *

* Note that CompositeMap is not synchronized and is not thread-safe. * If you wish to use this map from multiple threads concurrently, you must use * appropriate synchronization. The simplest approach is to wrap this map * using {@link java.util.Collections#synchronizedMap(Map)}. This class may throw * exceptions when accessed by concurrent threads without synchronization. * * @param the type of the keys in this map * @param the type of the values in this map * @since 3.0 */ public class CompositeMap extends AbstractIterableMap implements Serializable { /** Serialization version */ private static final long serialVersionUID = -6096931280583808322L; /** Array of all maps in the composite */ private Map[] composite; /** Handle mutation operations */ private MapMutator mutator; /** * Create a new, empty, CompositeMap. */ @SuppressWarnings("unchecked") public CompositeMap() { this(new Map[] {}, null); } /** * Create a new CompositeMap with two composited Map instances. * * @param one the first Map to be composited * @param two the second Map to be composited * @throws IllegalArgumentException if there is a key collision */ @SuppressWarnings("unchecked") public CompositeMap(final Map one, final Map two) { this(new Map[] { one, two }, null); } /** * Create a new CompositeMap with two composited Map instances. * * @param one the first Map to be composited * @param two the second Map to be composited * @param mutator MapMutator to be used for mutation operations */ @SuppressWarnings("unchecked") public CompositeMap(final Map one, final Map two, final MapMutator mutator) { this(new Map[] { one, two }, mutator); } /** * Create a new CompositeMap which composites all of the Map instances in the * argument. It copies the argument array, it does not use it directly. * * @param composite the Maps to be composited * @throws IllegalArgumentException if there is a key collision */ public CompositeMap(final Map... composite) { this(composite, null); } /** * Create a new CompositeMap which composites all of the Map instances in the * argument. It copies the argument array, it does not use it directly. * * @param composite Maps to be composited * @param mutator MapMutator to be used for mutation operations */ @SuppressWarnings("unchecked") public CompositeMap(final Map[] composite, final MapMutator mutator) { this.mutator = mutator; this.composite = new Map[0]; for (int i = composite.length - 1; i >= 0; --i) { this.addComposited(composite[i]); } } //----------------------------------------------------------------------- /** * Specify the MapMutator to be used by mutation operations. * * @param mutator the MapMutator to be used for mutation delegation */ public void setMutator(final MapMutator mutator) { this.mutator = mutator; } /** * Add an additional Map to the composite. * * @param map the Map to be added to the composite * @throws IllegalArgumentException if there is a key collision and there is no * MapMutator set to handle it. */ @SuppressWarnings("unchecked") public synchronized void addComposited(final Map map) throws IllegalArgumentException { for (int i = composite.length - 1; i >= 0; --i) { final Collection intersect = CollectionUtils.intersection(this.composite[i].keySet(), map.keySet()); if (intersect.size() != 0) { if (this.mutator == null) { throw new IllegalArgumentException("Key collision adding Map to CompositeMap"); } this.mutator.resolveCollision(this, this.composite[i], map, intersect); } } final Map[] temp = new Map[this.composite.length + 1]; System.arraycopy(this.composite, 0, temp, 0, this.composite.length); temp[temp.length - 1] = map; this.composite = temp; } /** * Remove a Map from the composite. * * @param map the Map to be removed from the composite * @return The removed Map or null if map is not in the composite */ @SuppressWarnings("unchecked") public synchronized Map removeComposited(final Map map) { final int size = this.composite.length; for (int i = 0; i < size; ++i) { if (this.composite[i].equals(map)) { final Map[] temp = new Map[size - 1]; System.arraycopy(this.composite, 0, temp, 0, i); System.arraycopy(this.composite, i + 1, temp, i, size - i - 1); this.composite = temp; return map; } } return null; } //----------------------------------------------------------------------- /** * Calls clear() on all composited Maps. * * @throws UnsupportedOperationException if any of the composited Maps do not support clear() */ @Override public void clear() { for (int i = this.composite.length - 1; i >= 0; --i) { this.composite[i].clear(); } } /** * Returns {@code true} if this map contains a mapping for the specified * key. More formally, returns {@code true} if and only if * this map contains at a mapping for a key {@code k} such that * {@code (key==null ? k==null : key.equals(k))}. (There can be * at most one such mapping.) * * @param key key whose presence in this map is to be tested. * @return {@code true} if this map contains a mapping for the specified * key. * * @throws ClassCastException if the key is of an inappropriate type for * this map (optional). * @throws NullPointerException if the key is {@code null} and this map * does not not permit {@code null} keys (optional). */ @Override public boolean containsKey(final Object key) { for (int i = this.composite.length - 1; i >= 0; --i) { if (this.composite[i].containsKey(key)) { return true; } } return false; } /** * Returns {@code true} if this map maps one or more keys to the * specified value. More formally, returns {@code true} if and only if * this map contains at least one mapping to a value {@code v} such that * {@code (value==null ? v==null : value.equals(v))}. This operation * will probably require time linear in the map size for most * implementations of the {@code Map} interface. * * @param value value whose presence in this map is to be tested. * @return {@code true} if this map maps one or more keys to the * specified value. * @throws ClassCastException if the value is of an inappropriate type for * this map (optional). * @throws NullPointerException if the value is {@code null} and this map * does not not permit {@code null} values (optional). */ @Override public boolean containsValue(final Object value) { for (int i = this.composite.length - 1; i >= 0; --i) { if (this.composite[i].containsValue(value)) { return true; } } return false; } /** * Returns a set view of the mappings contained in this map. Each element * in the returned set is a Map.Entry. The set is backed by the * map, so changes to the map are reflected in the set, and vice-versa. * If the map is modified while an iteration over the set is in progress, * the results of the iteration are undefined. The set supports element * removal, which removes the corresponding mapping from the map, via the * {@code Iterator.remove}, {@code Set.remove}, {@code removeAll}, * {@code retainAll} and {@code clear} operations. It does not support * the {@code add} or {@code addAll} operations. *

* This implementation returns a CompositeSet which * composites the entry sets from all of the composited maps. * * @see CompositeSet * @return a set view of the mappings contained in this map. */ @Override public Set> entrySet() { final CompositeSet> entries = new CompositeSet<>(); for (int i = composite.length - 1; i >= 0; --i) { entries.addComposited(composite[i].entrySet()); } return entries; } /** * Returns the value to which this map maps the specified key. Returns * {@code null} if the map contains no mapping for this key. A return * value of {@code null} does not necessarily indicate that the * map contains no mapping for the key; it's also possible that the map * explicitly maps the key to {@code null}. The {@code containsKey} * operation may be used to distinguish these two cases. * *

More formally, if this map contains a mapping from a key * {@code k} to a value {@code v} such that (key==null ? k==null : * key.equals(k)), then this method returns {@code v}; otherwise * it returns {@code null}. (There can be at most one such mapping.) * * @param key key whose associated value is to be returned. * @return the value to which this map maps the specified key, or * {@code null} if the map contains no mapping for this key. * * @throws ClassCastException if the key is of an inappropriate type for * this map (optional). * @throws NullPointerException key is {@code null} and this map does not * not permit {@code null} keys (optional). * * @see #containsKey(Object) */ @Override public V get(final Object key) { for (int i = this.composite.length - 1; i >= 0; --i) { if (this.composite[i].containsKey(key)) { return this.composite[i].get(key); } } return null; } /** * Returns {@code true} if this map contains no key-value mappings. * * @return {@code true} if this map contains no key-value mappings. */ @Override public boolean isEmpty() { for (int i = this.composite.length - 1; i >= 0; --i) { if (!this.composite[i].isEmpty()) { return false; } } return true; } /** * Returns a set view of the keys contained in this map. The set is * backed by the map, so changes to the map are reflected in the set, and * vice-versa. If the map is modified while an iteration over the set is * in progress, the results of the iteration are undefined. The set * supports element removal, which removes the corresponding mapping from * the map, via the {@code Iterator.remove}, {@code Set.remove}, * {@code removeAll} {@code retainAll}, and {@code clear} operations. * It does not support the add or {@code addAll} operations. *

* This implementation returns a CompositeSet which * composites the key sets from all of the composited maps. * * @return a set view of the keys contained in this map. */ @Override public Set keySet() { final CompositeSet keys = new CompositeSet<>(); for (int i = this.composite.length - 1; i >= 0; --i) { keys.addComposited(this.composite[i].keySet()); } return keys; } /** * Associates the specified value with the specified key in this map * (optional operation). If the map previously contained a mapping for * this key, the old value is replaced by the specified value. (A map * {@code m} is said to contain a mapping for a key {@code k} if and only * if {@link #containsKey(Object) m.containsKey(k)} would return * {@code true}.)) * * @param key key with which the specified value is to be associated. * @param value value to be associated with the specified key. * @return previous value associated with specified key, or {@code null} * if there was no mapping for key. A {@code null} return can * also indicate that the map previously associated {@code null} * with the specified key, if the implementation supports * {@code null} values. * * @throws UnsupportedOperationException if no MapMutator has been specified * @throws ClassCastException if the class of the specified key or value * prevents it from being stored in this map. * @throws IllegalArgumentException if some aspect of this key or value * prevents it from being stored in this map. * @throws NullPointerException this map does not permit {@code null} * keys or values, and the specified key or value is * {@code null}. */ @Override public V put(final K key, final V value) { if (this.mutator == null) { throw new UnsupportedOperationException("No mutator specified"); } return this.mutator.put(this, this.composite, key, value); } /** * Copies all of the mappings from the specified map to this map * (optional operation). The effect of this call is equivalent to that * of calling {@link #put(Object,Object) put(k, v)} on this map once * for each mapping from key {@code k} to value {@code v} in the * specified map. The behavior of this operation is unspecified if the * specified map is modified while the operation is in progress. * * @param map Mappings to be stored in this map. * * @throws UnsupportedOperationException if the {@code putAll} method is * not supported by this map. * * @throws ClassCastException if the class of a key or value in the * specified map prevents it from being stored in this map. * * @throws IllegalArgumentException some aspect of a key or value in the * specified map prevents it from being stored in this map. * @throws NullPointerException the specified map is {@code null}, or if * this map does not permit {@code null} keys or values, and the * specified map contains {@code null} keys or values. */ @Override public void putAll(final Map map) { if (this.mutator == null) { throw new UnsupportedOperationException("No mutator specified"); } this.mutator.putAll(this, this.composite, map); } /** * Removes the mapping for this key from this map if it is present * (optional operation). More formally, if this map contains a mapping * from key {@code k} to value {@code v} such that * (key==null ? k==null : key.equals(k)), that mapping * is removed. (The map can contain at most one such mapping.) * *

Returns the value to which the map previously associated the key, or * {@code null} if the map contained no mapping for this key. (A * {@code null} return can also indicate that the map previously * associated {@code null} with the specified key if the implementation * supports {@code null} values.) The map will not contain a mapping for * the specified key once the call returns. * * @param key key whose mapping is to be removed from the map. * @return previous value associated with specified key, or {@code null} * if there was no mapping for key. * * @throws ClassCastException if the key is of an inappropriate type for * the composited map (optional). * @throws NullPointerException if the key is {@code null} and the composited map * does not not permit {@code null} keys (optional). * @throws UnsupportedOperationException if the {@code remove} method is * not supported by the composited map containing the key */ @Override public V remove(final Object key) { for (int i = this.composite.length - 1; i >= 0; --i) { if (this.composite[i].containsKey(key)) { return this.composite[i].remove(key); } } return null; } /** * Returns the number of key-value mappings in this map. If the * map contains more than {@code Integer.MAX_VALUE} elements, returns * {@code Integer.MAX_VALUE}. * * @return the number of key-value mappings in this map. */ @Override public int size() { int size = 0; for (int i = this.composite.length - 1; i >= 0; --i) { size += this.composite[i].size(); } return size; } /** * Returns a collection view of the values contained in this map. The * collection is backed by the map, so changes to the map are reflected in * the collection, and vice-versa. If the map is modified while an * iteration over the collection is in progress, the results of the * iteration are undefined. The collection supports element removal, * which removes the corresponding mapping from the map, via the * {@code Iterator.remove}, {@code Collection.remove}, * {@code removeAll}, {@code retainAll} and {@code clear} operations. * It does not support the add or {@code addAll} operations. * * @return a collection view of the values contained in this map. */ @Override public Collection values() { final CompositeCollection values = new CompositeCollection<>(); for (int i = composite.length - 1; i >= 0; --i) { values.addComposited(composite[i].values()); } return values; } /** * Checks if this Map equals another as per the Map specification. * * @param obj the object to compare to * @return true if the maps are equal */ @Override public boolean equals(final Object obj) { if (obj instanceof Map) { final Map map = (Map) obj; return this.entrySet().equals(map.entrySet()); } return false; } /** * Gets a hash code for the Map as per the Map specification. * {@inheritDoc} */ @Override public int hashCode() { int code = 0; for (final Map.Entry entry : entrySet()) { code += entry.hashCode(); } return code; } /** * This interface allows definition for all of the indeterminate * mutators in a CompositeMap, as well as providing a hook for * callbacks on key collisions. * * @param the type of the keys in the map * @param the type of the values in the map */ public interface MapMutator extends Serializable { /** * Called when adding a new Composited Map results in a * key collision. * * @param composite the CompositeMap with the collision * @param existing the Map already in the composite which contains the * offending key * @param added the Map being added * @param intersect the intersection of the keysets of the existing and added maps */ void resolveCollision(CompositeMap composite, Map existing, Map added, Collection intersect); /** * Called when the CompositeMap.put() method is invoked. * * @param map the CompositeMap which is being modified * @param composited array of Maps in the CompositeMap being modified * @param key key with which the specified value is to be associated. * @param value value to be associated with the specified key. * @return previous value associated with specified key, or {@code null} * if there was no mapping for key. A {@code null} return can * also indicate that the map previously associated {@code null} * with the specified key, if the implementation supports * {@code null} values. * * @throws UnsupportedOperationException if not defined * @throws ClassCastException if the class of the specified key or value * prevents it from being stored in this map. * @throws IllegalArgumentException if some aspect of this key or value * prevents it from being stored in this map. * @throws NullPointerException this map does not permit {@code null} * keys or values, and the specified key or value is * {@code null}. */ V put(CompositeMap map, Map[] composited, K key, V value); /** * Called when the CompositeMap.putAll() method is invoked. * * @param map the CompositeMap which is being modified * @param composited array of Maps in the CompositeMap being modified * @param mapToAdd Mappings to be stored in this CompositeMap * * @throws UnsupportedOperationException if not defined * @throws ClassCastException if the class of the specified key or value * prevents it from being stored in this map. * @throws IllegalArgumentException if some aspect of this key or value * prevents it from being stored in this map. * @throws NullPointerException this map does not permit {@code null} * keys or values, and the specified key or value is * {@code null}. */ void putAll(CompositeMap map, Map[] composited, Map mapToAdd); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy