/*******************************************************************************
* Copyright (c) 2010 SAP AG.
* 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:
* Emil Simeonov - initial API and implementation.
* Dimitar Donchev - initial API and implementation.
* Dimitar Tenev - initial API and implementation.
* Nevena Manova - initial API and implementation.
* Georgi Konstantinov - initial API and implementation.
* Jakob Spies - initial API and implementation.
*******************************************************************************/
package org.eclipse.wst.sse.sieditor.core.common;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
/**
* Collection utility functions.
*/
public class CollectionTypeUtils
{
/**
* Replaces the content of one {@link Collection} with the content of another one
* if they are not equal.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @pre source != null
* @pre target != null
*/
public static <T> void copyContents(
final Collection<T> source,
final Collection<T> target
){
if (!Checker.isEqual(source, target)){
copyContentsWithoutCheck(source, target);
}
}
/**
* Returns an object different from the given one.
* @param set the set to search
* @param obj the object to avoid
* @param <T> type of the objects
* @param equal equality relation to use for comparison
* @return an object different from <code>obj</code>,
* if there is one, otherwise nil
* @pre docs != null
* @pre schema != null
*/
public static <T> T findOther(
final Collection<? extends T> set,
final T obj,
final Equal<? super T> equal
){
Nil.checkNil(set, "docs"); //$NON-NLS-1$
T res = null;
for (final T doc: set){
if (!equal.isEqual(doc, obj)){
res = doc;
break;
}
}
return res;
}
/**
* Replaces the content of one {@link Collection} with the content of another one
* if they are not equal.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @param equal the comparison operator
* @pre source != null
* @pre target != null
*/
public static <T> void copyContents(
final Collection<T> source,
final Collection<T> target,
final Equal<? super T> equal
){
if (!Checker.isEqual(source, target, equal)){
copyContentsWithoutCheck(source, target);
}
}
/**
* Replaces the content of one {@link Collection} with the content of another one,
* clearing the source {@link Collection} first,
* if they are not equal.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @param equal equality relation for <code>T</code> objects
* @pre source != null
* @pre target != null
*/
public static <T> void moveContents(
final Collection<T> source,
final Collection<T> target,
final Equal<T> equal
){
if (!Checker.isEqual(source, target, equal)){
clearSourceAndTargetAndCopy(source, target);
}
}
/**
* Replaces the content of one {@link Collection} with the content of another one
* without checking equality. The target <em>and source</em> {@link Collection}s
* are emptied before the
* target {@link Collection} is filled.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @pre source != null
* @pre target != null
*/
public static <T> void clearSourceAndTargetAndCopy(
final Collection<T> source,
final Collection<T> target
){
Nil.checkNil(source, "source"); //$NON-NLS-1$
Nil.checkNil(target, "target"); //$NON-NLS-1$
final Collection<T> copy = duplicate(source);
source.clear();
target.clear();
target.addAll(copy);
}
/**
* Replaces the content of one {@link Collection} with the content of another one
* without checking equality. The <em>source</em> {@link Collection}
* is emptied before the
* target {@link Collection} is filled.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @pre source != null
* @pre target != null
*/
public static <T> void clearSourceAndCopy(
final Collection<T> source,
final Collection<T> target
){
Nil.checkNil(source, "source"); //$NON-NLS-1$
Nil.checkNil(target, "target"); //$NON-NLS-1$
final Collection<T> copy = duplicate(source);
source.clear();
target.addAll(copy);
}
/**
* Returns a new {@link ArrayList} with the same contents as <code>source</code>,
* except for the case that <code>source</code> is nil or empty, in which <code>source</code>
* itself is returned.
* @param <T> element type
* @param source the {@link Collection} to clone
* @return a new {@link ArrayList} with the same contents as <code>source</code>,
* except for the case that <code>source</code> is nil or empty, in which <code>source</code>
* itself is returned
*/
public static <T> Collection<T> duplicate(Collection<T> source){
final Collection<T> result;
if (source == null || source.isEmpty()){
result = source;
}else{
result = new ArrayList<T>(source.size());
result.addAll(source);
}
return result;
}
/**
* Replaces the content of one {@link Collection} with the content of another one
* without checking equality. Cears the source collection afterwards.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @pre source != null
* @pre target != null
*/
public static <T> void moveContentsWithoutCheck(
final Collection<T> source,
final Collection<T> target
){
Nil.checkNil(source, "source"); //$NON-NLS-1$
Nil.checkNil(target, "target"); //$NON-NLS-1$
target.clear();
target.addAll(source);
source.clear();
}
/**
* Tries to find an one occurrence of an object in the given collection.
* @param objects the set to search
* @param <T> the object type
* @param criterion the search criterion
* @return the found object if it was found, nil otherwise
* @pre objects != null
* @pre criterion != null
*/
public static <T> List<T> find(
final Collection<T> objects,
final Condition<? super T> criterion
){
Nil.checkNil(objects, "objects"); //$NON-NLS-1$
Nil.checkNil(criterion, "criterion"); //$NON-NLS-1$
List<T> findings = new ArrayList<T>();
for (final T obj: objects){
if (criterion.isSatisfied(obj)){
findings.add(obj);
}
}
return findings;
}
/**
* Returns the position of the first occurrence of an object in the given sequence.
* @param objects the sequence to search
* @param <T> the object type
* @param criterion the search criterion
* @return the position of the first occurrence of the object if it was found, -1 otherwise
* @pre objects != null
* @pre criterion != null
*/
public static <T> int indexOf(
final List<? extends T> objects,
final Condition<T> criterion
){
Nil.checkNil(objects, "objects"); //$NON-NLS-1$
Nil.checkNil(criterion, "criterion"); //$NON-NLS-1$
int found = -1;
for (int i = 0, n = objects.size(); i < n; ++i){
if (criterion.isSatisfied(objects.get(i))){
found = i;
break;
}
}
return found;
}
/**
* Returns all occurrences of objects satisfying some <code>criterion</code>
* in the given collection.
* @param objects the set to search
* @param criterion the search criterion
* @param <T> the object type
* @return the objects satisfying the <code>criterion</code>
* @pre objects != null
* @pre criterion != null
* @post return != null
*/
public static <T> Collection<T> findAll(
final Collection<T> objects,
final Condition<? super T> criterion
){
Nil.checkNil(objects, "objects"); //$NON-NLS-1$
Nil.checkNil(criterion, "criterion"); //$NON-NLS-1$
Collection<T> found = null;
for (final T obj: objects){
if (criterion.isSatisfied(obj)){
if (found == null){
found = new LinkedList<T>();
}
found.add(obj);
}
}
if (found == null){
found = Collections.emptyList();
}
return found;
}
/**
* Returns all occurrences of objects of a certain runtime type
* in the given collection.
* @param objects the set to search
* @param type the target type
* @param <T> the target type
* @return the objects of type <code>type</code>
* @pre objects != null
* @pre type != null
* @post return != null
*/
public static <T> Collection<T> findAllOfType(
final Collection<? super T> objects,
final Class<T> type
){
Nil.checkNil(objects, "objects"); //$NON-NLS-1$
Nil.checkNil(type, "type"); //$NON-NLS-1$
Collection<T> found = null;
for (final Object obj: objects){
if (type.isInstance(obj)){
if (found == null){
found = new LinkedList<T>();
}
found.add((T)obj);
}
}
if (found == null){
found = Collections.emptyList();
}
return found;
}
/**
* Returns all occurrences objects satisfying some <code>criterion</code> in the given collection.
* @param objects the set to search
* @param criterion the search criterion
* @param <T> the object type
* @return the objects satisfying the <code>criterion</code>
* @pre objects != null
* @pre criterion != null
* @post return != null
*/
public static <T> Set<T> findAllAsSet(
final Collection<T> objects,
final Condition<? super T> criterion
){
Nil.checkNil(objects, "objects"); //$NON-NLS-1$
Nil.checkNil(criterion, "criterion"); //$NON-NLS-1$
Set<T> found = null;
for (final T obj: objects){
if (criterion.isSatisfied(obj)){
if (found == null){
found = new HashSet<T>();
}
found.add(obj);
}
}
if (found == null){
found = Collections.emptySet();
}
return found;
}
/**
* Replaces the content of one {@link Collection} with the content of another one
* without checking equality.
* @param <T> content type
* @param source source {@link Collection}
* @param target target {@link Collection}
* @pre source != null
* @pre target != null
*/
private static <T> void copyContentsWithoutCheck(
final Collection<T> source,
final Collection<T> target
){
Nil.checkNil(source, "source"); //$NON-NLS-1$
Nil.checkNil(target, "target"); //$NON-NLS-1$
target.clear();
target.addAll(source);
}
/**
* Search whether any object in 'objects' array does equal 'searchForObject'.
* @param objects can be null, and can contain null values
* @param searchForObject can be null
* @return true if searchForObject is found in 'objects'
*/
public static boolean containsObject(Object objects[], Object searchForObject) {
if(objects == null) {
return false;
}
for(Object object : objects) {
boolean found = object == null ? searchForObject == null : object.equals(searchForObject);
if(found) {
return true;
}
}
return false;
}
}