Java tutorial
/* * 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 de.dal33t.powerfolder.util.collection; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * Decorates a set of other sets to provide a single unified view. * <p> * Changes made to this set will actually be made on the decorated set. Add * operations require the use of a pluggable strategy. If no strategy is * provided then add is unsupported. * * @since Commons Collections 3.0 * @version $Revision: 646777 $ $Date: 2008-04-10 13:33:15 +0100 (Thu, 10 Apr * 2008) $ * @author Brian McCallister */ public class CompositeSet extends CompositeCollection implements Set { /** * Create an empty CompositeSet */ public CompositeSet() { super(); } /** * Create a CompositeSet with just <code>set</code> composited * * @param set * The initial set in the composite */ public CompositeSet(Set set) { super(set); } /** * Create a composite set with sets as the initial set of composited Sets */ public CompositeSet(Set[] sets) { super(sets); } /** * Add a Set to this composite * * @param c * Must implement Set * @throws IllegalArgumentException * if c does not implement java.util.Set or if a SetMutator is * set, but fails to resolve a collision * @throws UnsupportedOperationException * if there is no SetMutator set, or a CollectionMutator is set * instead of a SetMutator * @see org.apache.commons.collections.collection.CompositeCollection.CollectionMutator * @see SetMutator */ public synchronized void addComposited(Collection c) { if (!(c instanceof Set)) { throw new IllegalArgumentException("Collections added must implement java.util.Set"); } for (Iterator i = this.getCollections().iterator(); i.hasNext();) { Set set = (Set) i.next(); Collection intersects = intersection(set, c); if (intersects.size() > 0) { if (this.mutator == null) { throw new UnsupportedOperationException( "Collision adding composited collection with no SetMutator set"); } else if (!(this.mutator instanceof SetMutator)) { throw new UnsupportedOperationException( "Collision adding composited collection to a CompositeSet with a CollectionMutator instead of a SetMutator"); } ((SetMutator) this.mutator).resolveCollision(this, set, (Set) c, intersects); if (intersection(set, c).size() > 0) { throw new IllegalArgumentException( "Attempt to add illegal entry unresolved by SetMutator.resolveCollision()"); } } } super.addComposited(new Collection[] { c }); } /** * Add two sets to this composite * * @throws IllegalArgumentException * if c or d does not implement java.util.Set */ public synchronized void addComposited(Collection c, Collection d) { if (!(c instanceof Set)) throw new IllegalArgumentException("Argument must implement java.util.Set"); if (!(d instanceof Set)) throw new IllegalArgumentException("Argument must implement java.util.Set"); this.addComposited(new Set[] { (Set) c, (Set) d }); } /** * Add an array of sets to this composite * * @param comps * @throws IllegalArgumentException * if any of the collections in comps do not implement Set */ public synchronized void addComposited(Collection[] comps) { for (int i = comps.length - 1; i >= 0; --i) { this.addComposited(comps[i]); } } /** * This can receive either a * <code>CompositeCollection.CollectionMutator</code> or a * <code>CompositeSet.SetMutator</code>. If a * <code>CompositeCollection.CollectionMutator</code> is used than conflicts * when adding composited sets will throw IllegalArgumentException * <p> */ public void setMutator(CollectionMutator mutator) { super.setMutator(mutator); } /* Set operations */ /** * If a <code>CollectionMutator</code> is defined for this CompositeSet then * this method will be called anyway. * * @param obj * Object to be removed * @return true if the object is removed, false otherwise */ public boolean remove(Object obj) { for (Iterator i = this.getCollections().iterator(); i.hasNext();) { Set set = (Set) i.next(); if (set.contains(obj)) return set.remove(obj); } return false; } /** * @see Set#equals */ public boolean equals(Object obj) { if (obj instanceof Set) { Set set = (Set) obj; if (set.containsAll(this) && set.size() == this.size()) { return true; } } return false; } /** * @see Set#hashCode */ public int hashCode() { int code = 0; for (Iterator i = this.iterator(); i.hasNext();) { Object next = i.next(); code += (next != null ? next.hashCode() : 0); } return code; } /** * Returns a {@link Collection} containing the intersection of the given * {@link Collection}s. * <p> * The cardinality of each element in the returned {@link Collection} will * be equal to the minimum of the cardinality of that element in the two * given {@link Collection}s. * * @param a * the first collection, must not be null * @param b * the second collection, must not be null * @return the intersection of the two collections * @see Collection#retainAll * @see #containsAny */ public static Collection intersection(final Collection a, final Collection b) { ArrayList list = new ArrayList(); Map mapa = getCardinalityMap(a); Map mapb = getCardinalityMap(b); Set elts = new HashSet(a); elts.addAll(b); Iterator it = elts.iterator(); while (it.hasNext()) { Object obj = it.next(); for (int i = 0, m = Math.min(getFreq(obj, mapa), getFreq(obj, mapb)); i < m; i++) { list.add(obj); } } return list; } private static final int getFreq(final Object obj, final Map freqMap) { Integer count = (Integer) freqMap.get(obj); if (count != null) { return count.intValue(); } return 0; } private static Integer INTEGER_ONE = new Integer(1); /** * Returns a {@link Map} mapping each unique element in the given * {@link Collection} to an {@link Integer} representing the number of * occurrences of that element in the {@link Collection}. * <p> * Only those elements present in the collection will appear as keys in the * map. * * @param coll * the collection to get the cardinality map for, must not be * null * @return the populated cardinality map */ public static Map getCardinalityMap(final Collection coll) { Map count = new HashMap(); for (Iterator it = coll.iterator(); it.hasNext();) { Object obj = it.next(); Integer c = (Integer) (count.get(obj)); if (c == null) { count.put(obj, INTEGER_ONE); } else { count.put(obj, new Integer(c.intValue() + 1)); } } return count; } /** * Define callbacks for mutation operations. * <p> * Defining remove() on implementations of SetMutator is pointless as they * are never called by CompositeSet. */ public static interface SetMutator extends CompositeCollection.CollectionMutator { /** * <p> * Called when a Set is added to the CompositeSet and there is a * collision between existing and added sets. * </p> * <p> * If <code>added</code> and <code>existing</code> still have any * intersects after this method returns an IllegalArgumentException will * be thrown. * </p> * * @param comp * The CompositeSet being modified * @param existing * The Set already existing in the composite * @param added * the Set being added to the composite * @param intersects * the intersection of th existing and added sets */ public void resolveCollision(CompositeSet comp, Set existing, Set added, Collection intersects); } }