plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/DuplicatesTable.java

/*******************************************************************************
 * Copyright (c) 2001, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.j2ee.model.internal.validation;


import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * In some places in the code, it is necessary to find out if there
 * are duplicates in a list, and if there are, to register a validation
 * message against the duplicates. This class is used to make finding
 * the duplicates easier.
 */
public class DuplicatesTable extends java.util.HashMap {
	/**
	 * 
	 */
	private static final long serialVersionUID = -3189901849555229718L;
	protected static final Boolean UNIQUE = Boolean.FALSE;
	protected static final Boolean DUPLICATE = Boolean.TRUE;
	protected Map _duplicates = null;

	/**
	 * Add an object to this table; if the object is a duplicate, it will be
	 * marked to a duplicate instead of being added twice to the table.
	 */
	public void add(Object o) {
		// Build up hashtable to check for duplicate elements.
		Object key = get(o);
		if (key == null) {
			put(o, UNIQUE);
		}
		else {
			saveDuplicate(o);
			put(o, DUPLICATE);
		}
	}

	protected void saveDuplicate(Object o) {
		// The given object has been marked a duplicate.
		// Given that the HashMap can store only one object with the key, 
		// duplicates are overwritten. This method stores the duplicates
		// elsewhere in a List.
		if (_duplicates == null) {
			_duplicates = new HashMap();
		}

		List dupList = (List) _duplicates.get(o);
		if (dupList == null) {
			dupList = new ArrayList();
		}

		dupList.add(o);
		_duplicates.put(o, dupList);
	}

	/**
	 * If there are duplicates in this table, return true; else, return false.
	 */
	public boolean containsDuplicates() {
		return containsValue(DUPLICATE);
	}
	
	/**
	 * If there are unique elements in this table, return true; else, return false.
	 */
	public boolean containsUniques() {
		return containsValue(UNIQUE);
	}
	
	/**
	 * If there are duplicates in this table, return a set of the duplicates.
	 * Otherwise, return an empty set.
	 */
	public List getDuplicates() {
		if (!containsDuplicates()) {
			return Collections.EMPTY_LIST;
		}

		// Else, get the duplicate elements from the list
		return getElements(DUPLICATE);
	}
	
	/**
	 * If there are duplicates in this table, return a list of the duplicates.
	 * Otherwise, return an empty list.
	 */
	private List getElements(Boolean type) {
		if (type == null) {
			return Collections.EMPTY_LIST;
		}

		// Else, get the duplicate elements from the list
		Set keys = keySet();
		if (keys == null) {
			return Collections.EMPTY_LIST;
		}

		List elements = new ArrayList();
		Iterator iterator = keys.iterator();
		while (iterator.hasNext()) {
			Object key = iterator.next();
			Object value = get(key);
			if (value == type) {
				elements.add(key);
			}
		}

		if (type == DUPLICATE) {
			// Also add the elements from the "duplicates" list.
			if (_duplicates != null) {
				iterator = _duplicates.values().iterator();
				while (iterator.hasNext()) {
					List dupList = (List) iterator.next();
					elements.addAll(dupList);
				}
			}
		}

		return elements;
	}
	
	/**
	 * If there are unique elements in this table, return a set of the unique elements.
	 * Otherwise, return an empty set.
	 */
	public List getUniques() {
		if (!containsUniques()) {
			return Collections.EMPTY_LIST;
		}

		// Else, get the unique elements from the list
		return getElements(UNIQUE);
	}

	public void clear() {
		super.clear();
		if(_duplicates != null) {
			_duplicates.clear();
		}
	}
}