| /******************************************************************************* |
| * Copyright (c) 2006, 2012, 2011 IBM Corporation, Zeligsoft Inc., 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 - Initial API and implementation |
| * Zeligsoft - Bugs 244946, 248869 |
| * Axel Uhl (SAP AG) - Bug 342644 |
| *******************************************************************************/ |
| package org.eclipse.ocl.util; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.ocl.Environment; |
| import org.eclipse.ocl.EvaluationEnvironment; |
| import org.eclipse.ocl.expressions.CollectionKind; |
| import org.eclipse.ocl.internal.OCLPlugin; |
| import org.eclipse.ocl.internal.evaluation.NumberUtil; |
| import org.eclipse.ocl.internal.l10n.OCLMessages; |
| import org.eclipse.ocl.types.CollectionType; |
| |
| /** |
| * Utility methods for working with OCL collection values. |
| * |
| * @author Christian W. Damus (cdamus) |
| */ |
| public class CollectionUtil { |
| |
| // not instantiable |
| private CollectionUtil() { |
| super(); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::includes(object : T) : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return whether the collection includes the object |
| */ |
| public static boolean includes(Collection<?> self, Object object) { |
| return self.contains(object); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::excludes(object : T) : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return whether the collection does not include the object |
| */ |
| public static boolean excludes(Collection<?> self, Object object) { |
| return !includes(self, object); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::count(object : T) : Integer</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the number of occurrences of the object in the collection |
| */ |
| public static int count(Collection<?> self, Object object) { |
| int count = 0; |
| for (Object next : self) { |
| if (ObjectUtil.equal(next, object)) { |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::includesAll(c : Collection(T)) : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @param c another collection |
| * @return whether the source collection includes all of the elements |
| * of the other |
| */ |
| public static boolean includesAll(Collection<?> self, Collection<?> c) { |
| for (Object next : c) { |
| if (!includes(self, next)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::excludesAll(c : Collection(T)) : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @param c another collection |
| * @return whether the source collection does not contain any of the |
| * elements of the other |
| */ |
| public static boolean excludesAll(Collection<?> self, Collection<?> c) { |
| for (Object next : c) { |
| if (includes(self, next)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::isEmpty() : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @return whether the collection does not have any elements |
| */ |
| public static boolean isEmpty(Collection<?> self) { |
| return self.isEmpty(); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::max() : T</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @return the largest of the collection's elements |
| * @since 3.2 |
| */ |
| @SuppressWarnings("unchecked") |
| public static Object max(Collection<?> self) { |
| if (self.isEmpty()) { |
| return null; // undefined |
| } |
| Number maxVal = null; |
| for (Iterator<?> it = self.iterator(); it.hasNext();) { |
| Object object = it.next(); |
| if (!(object instanceof Number)) { |
| IllegalArgumentException error = new IllegalArgumentException(OCLMessages.MaxOperator_ERROR_); |
| OCLPlugin.throwing(CollectionUtil.class, "max", error);//$NON-NLS-1$ |
| throw error; |
| } |
| Number number = (Number)object; |
| if (maxVal == null) { |
| maxVal = number; |
| } |
| else { |
| maxVal = NumberUtil.commonPrecisionNumber(maxVal, number); |
| number = NumberUtil.commonPrecisionNumber(number, maxVal); |
| if (((Comparable<Number>)number).compareTo(maxVal) > 0) { |
| maxVal = number; |
| } |
| } |
| } |
| return NumberUtil.coerceNumber(maxVal); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::min() : T</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @return the smallest of the collection's elements |
| * @since 3.2 |
| */ |
| @SuppressWarnings("unchecked") |
| public static Object min(Collection<?> self) { |
| if (self.isEmpty()) { |
| return null; // undefined |
| } |
| Number maxVal = null; |
| for (Iterator<?> it = self.iterator(); it.hasNext();) { |
| Object object = it.next(); |
| if (!(object instanceof Number)) { |
| IllegalArgumentException error = new IllegalArgumentException(OCLMessages.MinOperator_ERROR_); |
| OCLPlugin.throwing(CollectionUtil.class, "min", error);//$NON-NLS-1$ |
| throw error; |
| } |
| Number number = (Number)object; |
| if (maxVal == null) { |
| maxVal = number; |
| } |
| else { |
| maxVal = NumberUtil.commonPrecisionNumber(maxVal, number); |
| number = NumberUtil.commonPrecisionNumber(number, maxVal); |
| if (((Comparable<Number>)number).compareTo(maxVal) < 0) { |
| maxVal = number; |
| } |
| } |
| } |
| return NumberUtil.coerceNumber(maxVal); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::notEmpty() : Boolean</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @return whether the collection has any elements |
| */ |
| public static boolean notEmpty(Collection<?> self) { |
| return !self.isEmpty(); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::sum() : T</tt> |
| * operation. |
| * |
| * @param self the source collection |
| * @return the sum of the collection's elements |
| */ |
| public static Object sum(Collection<?> self) { |
| if (self.isEmpty()) { |
| return null; // undefined |
| } |
| Number sumVal = null; |
| for (Iterator<?> it = self.iterator(); it.hasNext();) { |
| Object object = it.next(); |
| if (!(object instanceof Number)) { |
| IllegalArgumentException error = new IllegalArgumentException(OCLMessages.SumOperator_ERROR_); |
| OCLPlugin.throwing(CollectionUtil.class, "sum", error);//$NON-NLS-1$ |
| throw error; |
| } |
| Number number = (Number)object; |
| if (sumVal == null) { |
| sumVal = number; |
| } |
| else { |
| sumVal = NumberUtil.commonPrecisionNumber(sumVal, number); |
| number = NumberUtil.commonPrecisionNumber(number, sumVal); |
| if (sumVal instanceof BigDecimal) { |
| sumVal = ((BigDecimal)sumVal).add((BigDecimal)number); |
| } |
| else if (sumVal instanceof BigInteger) { |
| sumVal = ((BigInteger)sumVal).add((BigInteger)number); |
| } |
| else if (sumVal instanceof Double) { |
| sumVal = (Double)sumVal + (Double)number; |
| } |
| else { |
| sumVal = (Long)sumVal + (Long)number; |
| } |
| } |
| } |
| return NumberUtil.coerceNumber(sumVal); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::=(set : Set(T)) : Boolean</tt></li> |
| * <li><tt>OrderedSet::=(set : OrderedSet(T)) : Boolean</tt></li> |
| * <li><tt>Bag::=(bag : Bag(T)) : Boolean</tt></li> |
| * <li><tt>Sequence::=(s : Sequence(T)) : Boolean</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param c another collection of the same kind |
| * @return whether collections are equal |
| */ |
| public static boolean equals(Collection<?> self, Collection<?> c) { |
| if (self.size() != c.size()) { |
| // collections of different sizes cannot be equal |
| return false; |
| } else if (self instanceof Bag<?> && c instanceof Bag<?>) { |
| return ((Bag<?>) self).equals(c); |
| } else if (self instanceof List<?> && c instanceof List<?>) { |
| return ((List<?>) self).equals(c); |
| } else if (self instanceof LinkedHashSet<?> && c instanceof LinkedHashSet<?>) { |
| // OrderedSet |
| |
| // LinkedHashSet.equals() doesn't care about order but we do |
| int size1 = self.size(); |
| int size2 = c.size(); |
| if (size1 != size2) { |
| return false; |
| } |
| Iterator<?> it1 = self.iterator(); |
| Iterator<?> it2 = c.iterator(); |
| while (it1.hasNext()) { |
| Object o1 = it1.next(); |
| Object o2 = it2.next(); |
| if (!o1.equals(o2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } else if (self instanceof Set<?> && c instanceof Set<?>) { |
| return ((Set<?>) self).equals(c); |
| } else { |
| // incompatible OCL types |
| return false; |
| } |
| } |
| |
| /** |
| * Computes the hash of a collection, accounting for the similar hashing of |
| * primitive numeric values that OCL considers equal but Java does not. |
| * |
| * @param c a collection |
| * |
| * @return its hash |
| */ |
| public static int hashCode(Collection<?> c) { |
| int result = 1; |
| |
| for (Object next : c) { |
| result = 37 * result + ObjectUtil.hashCode(next); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::intersection(set : Set(T)) : Set(T)</tt></li> |
| * <li><tt>Set::intersection(bag : Bag(T)) : Set(T)</tt></li> |
| * <li><tt>Bag::intersection(set : Set(T)) : Set(T)</tt></li> |
| * <li><tt>Bag::intersection(bag : Bag(T)) : Set(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source set or bag |
| * @param c another set or bag |
| * @return the intersection of the source set or bag with the other set or bag |
| */ |
| public static <E> Collection<E> intersection( |
| Collection<? extends E> self, Collection<? extends E> c) { |
| |
| int size1 = self.size(); |
| int size2 = c.size(); |
| |
| // if either collection is empty, then so is the result |
| if (size1 == 0 || size2 == 0) { |
| if (self instanceof Set<?> || c instanceof Set<?>) { |
| return Collections.emptySet(); |
| } else { |
| return BagImpl.emptyBag(); |
| } |
| } |
| |
| Collection<E> result = null; |
| |
| if (self instanceof Set<?> || c instanceof Set<?>) { |
| // if either argument is a set, so is the result |
| if (size1 == 0 || size2 == 0) { |
| return Collections.emptySet(); |
| } |
| result = createNewSet(); |
| } else { |
| // both arguments are bags, so is the result |
| if (size1 == 0 || size2 == 0) { |
| return BagImpl.emptyBag(); |
| } |
| result = createNewBag(); |
| } |
| |
| // loop over the smaller collection and add only elements |
| // that are in the larger collection |
| if (self.size() > c.size()) { |
| for (E e : c) { |
| if (includes(self, e)) { |
| result.add(e); |
| } |
| } |
| } else { |
| for (E e : self) { |
| if (includes(c, e)) { |
| result.add(e); |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::union(set : Set(T)) : Set(T)</tt></li> |
| * <li><tt>Set::union(bag : Bag(T)) : Bag(T)</tt></li> |
| * <li><tt>Bag::union(set : Set(T)) : Bag(T)</tt></li> |
| * <li><tt>Bag::union(bag : Bag(T)) : Bag(T)</tt></li> |
| * <li><tt>Sequence::union(s : Sequence(T)) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param c another collection |
| * @return the union of the source collection with the other |
| */ |
| public static <E> Collection<E> union( |
| Collection<? extends E> self, Collection<? extends E> c) { |
| |
| // if either argument is empty, then the union is the other, |
| // except the source is a set and the other is a bag in which |
| // case the result has to be a bag |
| if (self.isEmpty()) { |
| if (self instanceof Bag || c instanceof Bag) { |
| return createNewBag(c); |
| } else { |
| return createNewCollection(c); |
| } |
| } else if (c.isEmpty()) { |
| if (self instanceof Bag || c instanceof Bag) { |
| return createNewBag(self); |
| } else { |
| return createNewCollection(self); |
| } |
| } |
| |
| Collection<E> result = null; |
| if (self instanceof Bag<?> || c instanceof Bag<?>) { |
| result = createNewBag(self); |
| } else if (self instanceof List<?> || c instanceof List<?>) { |
| result = createNewSequence(self); |
| } else { |
| result = createNewSet(self); |
| } |
| |
| result.addAll(c); |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::flatten() : Set(T2)</tt></li> |
| * <li><tt>Bag::flatten() : Bag(T2)</tt></li> |
| * <li><tt>Sequence::flatten() : Sequence(T2)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the flattened collection |
| */ |
| public static Collection<?> flatten(Collection<?> self) { |
| // Note: As OCL 2.3 (OMG 10-11-42) section A.2.5.8 fails to specify how to |
| // flatten an OrderedSet, we choose to flatten it into an OrderedSet |
| // represented by a LinkedHashSet. |
| Collection<?> result = self; |
| |
| for (;;) { |
| if (result.isEmpty()) { |
| break; |
| } |
| |
| Iterator<?> it = result.iterator(); |
| Object object = it.next(); |
| |
| // if the element type is not a collection type, the result is the |
| // current collection. |
| if (!(object instanceof Collection<?>)) { |
| break; |
| } |
| |
| Collection<Object> newResult = null; |
| if (result instanceof Bag<?>) { |
| newResult = createNewBag(); |
| } else if (result instanceof Set<?>) { |
| newResult = createNewSet(); |
| } else { |
| // Sequence |
| newResult = createNewSequence(); |
| } |
| |
| // the element type is a collection type -- flatten one level |
| newResult.addAll((Collection<?>) object); |
| while (it.hasNext()) { |
| newResult.addAll((Collection<?>) it.next()); |
| } |
| |
| result = newResult; |
| // loop until the result is empty or the first element is not a |
| // collection |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Obtains the type of the flattened form of the specified collection type. |
| * |
| * @param type a collection type |
| * @return the flattened collection type |
| * |
| * @since 1.2 |
| */ |
| @SuppressWarnings("unchecked") |
| public static <C> C getFlattenedElementType( |
| CollectionType<C, ?> type) { |
| |
| C result = type.getElementType(); |
| |
| while (result instanceof CollectionType<?, ?>) { |
| result = ((CollectionType<C, ?>) result).getElementType(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Set::-(set : Set(T)) : Set(T)</tt> |
| * operation. |
| * |
| * @param self the source set |
| * @param set another set |
| * @return the subtraction of the other set from the source set |
| */ |
| public static <E> Set<E> minus(Set<? extends E> self, Set<? extends E> set) { |
| Set<E> result = createNewSet(self); |
| result.removeAll(set); |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::excluding(object : T) : Set(T)</tt></li> |
| * <li><tt>Bag::excluding(object : T) : Bag(T)</tt></li> |
| * <li><tt>Sequence::excluding(object : T) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the source collection without any occurences of the object |
| */ |
| public static <E> Collection<E> excluding(Collection<E> self, Object object) { |
| Collection<E> result = null; |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(self); |
| } else if (self instanceof Set<?>) { |
| result = createNewSet(self); |
| } else if (self instanceof Bag<?>) { |
| result = createNewBag(self); |
| } else if (self instanceof List<?>) { |
| List<E> resultSeq = createNewSequence(self); |
| while (resultSeq.remove(object)) { |
| ; // for sequences we need to remove all the matching elements |
| } |
| return resultSeq; |
| } else { |
| throw new RuntimeException("Unsupported collection type "+self.getClass().getName()); //$NON-NLS-1$ |
| } |
| |
| // non-sequences (bags remove all occurrences internally) |
| result.remove(object); |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Set::symmetricDifference(set : Set(T)) : Set(T)</tt> |
| * operation. |
| * |
| * @param self the source set |
| * @param set another set |
| * @return the set of elements in either the source or the other set but not |
| * in both |
| */ |
| public static <E> Set<E> symmetricDifference(Set<? extends E> self, |
| Set<? extends E> set) { |
| |
| Set<E> result = createNewSet(self); |
| |
| for (E e : set) { |
| if (result.contains(e)) { |
| result.remove(e); |
| } else { |
| result.add(e); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::including(object : T) : Set(T)</tt></li> |
| * <li><tt>Bag::including(object : T) : Bag(T)</tt></li> |
| * <li><tt>Sequence::including(object : T) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the source collection with the object added |
| */ |
| public static <E> Collection<E> including(Collection<E> self, E object) { |
| Collection<E> result; |
| |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(self); |
| } else if (self instanceof Set<?>) { |
| result = createNewSet(self); |
| } else if (self instanceof Bag<?>) { |
| result = createNewBag(self); |
| } else { |
| result = createNewSequence(self); |
| } |
| |
| result.add(object); |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::asSet() : Set(T)</tt></li> |
| * <li><tt>Bag::asSet() : Set(T)</tt></li> |
| * <li><tt>Sequence::asSet() : Set(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the source collection as a set |
| */ |
| public static <E> Set<E> asSet(Collection<E> self) { |
| if (self instanceof Set<?> && !(self instanceof LinkedHashSet<?>)) { |
| return (Set<E>) self; |
| } |
| return createNewSet(self); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::asBag() : Bag(T)</tt></li> |
| * <li><tt>Bag::asBag() : Bag(T)</tt></li> |
| * <li><tt>Sequence::asBag() : Bag(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the source collection as a bag |
| */ |
| public static <E> Bag<E> asBag(Collection<E> self) { |
| if (self instanceof Bag<?>) { |
| return (Bag<E>) self; |
| } |
| return createNewBag(self); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::asSequence() : Sequence(T)</tt></li> |
| * <li><tt>Bag::asSequence() : Sequence(T)</tt></li> |
| * <li><tt>Sequence::asSequence() : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the source collection as a sequence |
| */ |
| public static <E> List<E> asSequence(Collection<E> self) { |
| if (self instanceof List<?>) { |
| return (List<E>) self; |
| } |
| return createNewSequence(self); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>Set::asOrderedSet() : OrderedSet(T)</tt></li> |
| * <li><tt>Bag::asOrderedSet() : OrderedSet(T)</tt></li> |
| * <li><tt>Sequence::asOrderedSet() : OrderedSet(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the source collection as an ordered set |
| */ |
| public static <E> LinkedHashSet<E> asOrderedSet(Collection<E> self) { |
| // TODO: create an interface for OrderedSet |
| if (self instanceof LinkedHashSet<?>) { |
| return (LinkedHashSet<E>) self; |
| } |
| return createNewOrderedSet(self); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2))</tt> |
| * operations. |
| * |
| * @param evalEnv the current evaluation environment (for construction of |
| * tuples) |
| * @param env the current OCL environment (for introspection of the tuple type) |
| * @param self the source collection |
| * @param c another collection |
| * @return the product of the collections |
| */ |
| public static<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> |
| Set<Tuple<O, P>> product(EvaluationEnvironment<C, O, P, CLS, E> evalEnv, |
| Environment<PK, C, O, P, EL, PM, S, COA, SSA, CT, CLS, E> env, |
| Collection<?> self, Collection<?> c, C tupleType) { |
| |
| Set<Tuple<O, P>> result = createNewSet(); |
| |
| Map<P, Object> propertyValues = new HashMap<P, Object>(); |
| P firstProperty = env.lookupProperty( |
| tupleType, |
| OCLStandardLibraryUtil.PRODUCT_FIRST); |
| P secondProperty = env.lookupProperty( |
| tupleType, |
| OCLStandardLibraryUtil.PRODUCT_SECOND); |
| |
| for (Object next1 : self) { |
| for (Object next2 : c) { |
| propertyValues.put(firstProperty, next1); |
| propertyValues.put(secondProperty, next2); |
| |
| result.add(evalEnv.createTuple(tupleType, propertyValues)); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::append(object : T) : OrderedSet(T)</tt></li> |
| * <li><tt>Sequence::append(object : T) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the source collection with the object appended |
| */ |
| public static <E> Collection<E> append(Collection<E> self, E object) { |
| Collection<E> result; |
| // TODO: make an interface for OrderedSet |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(self); |
| result.remove(object); // appended object must be last |
| } else { |
| result = createNewSequence(self); |
| } |
| |
| result.add(object); |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::prepend(object : T) : OrderedSet(T)</tt></li> |
| * <li><tt>Sequence::prepend(object : T) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the source collection with the object prepended |
| */ |
| public static <E> Collection<E> prepend(Collection<E> self, E object) { |
| Collection<E> result; |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(); |
| } else { |
| result = createNewSequence(); |
| } |
| result.add(object); |
| result.addAll(self); |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::insertAt(index : Integer, object : T) : OrderedSet(T)</tt></li> |
| * <li><tt>Sequence::insertAt(index : Integer, object : T) : Sequence(T)</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param index the 1-based (in OCL fashion) index |
| * @param object an object |
| * @return the source collection with the object inserted at the index |
| * |
| * @throws IndexOutOfBoundsException if the index is out of bounds |
| */ |
| public static <E> Collection<E> insertAt(Collection<E> self, int index, E object) { |
| index = index - 1; |
| |
| if (index < 0 || index > self.size()) { |
| throw new IndexOutOfBoundsException( |
| "index: " + (index + 1) + ", size: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + self.size()); |
| } |
| |
| Collection<E> result; |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(); |
| } else { |
| result = createNewSequence(); |
| } |
| |
| int curr = 0; |
| for (Iterator<E> it = self.iterator(); it.hasNext();) { |
| if (curr == index) { |
| result.add(object); |
| } |
| result.add(it.next()); |
| curr++; |
| } |
| |
| if (index == self.size()) { |
| // the loop finished before we could add the object |
| result.add(object); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>OrderedSet::subOrderedSet(lower : Integer, upper : Integer) : OrderedSet(T)</tt> |
| * operation. |
| * |
| * @param self the source set |
| * @param lower the 1-based (in OCL fashion) inclusive lower bound |
| * @param upper the 1-based (in OCL fashion) inclusive upper bound |
| * @return the slice of the source set |
| * |
| * @throws IndexOutOfBoundsException if an index is out of bounds |
| * @throws IllegalArgumentException if the lower bound is greater than the upper |
| */ |
| public static <E> Collection<E> subOrderedSet(Collection<E> self, int lower, |
| int upper) { |
| lower = lower - 1; |
| upper = upper - 1; |
| |
| if (lower < 0) { |
| throw new IndexOutOfBoundsException("lower: " + (lower + 1)); //$NON-NLS-1$ |
| } else if (upper >= self.size()) { |
| throw new IndexOutOfBoundsException( |
| "upper: " + (upper + 1) + ", size: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + self.size()); |
| } else if (upper < lower) { |
| throw new IllegalArgumentException( |
| "lower: " + (lower + 1) + ", upper: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + (upper + 1)); |
| } |
| |
| Collection<E> result; |
| if (self instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(); |
| } else { |
| result = createNewSequence(); |
| } |
| int curr = 0; |
| for (Iterator<E> it = self.iterator(); it.hasNext();) { |
| E object = it.next(); |
| if (curr >= lower && curr <= upper) { |
| result.add(object); |
| } |
| curr++; |
| } |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <tt>Sequence::subSequence(lower : Integer, upper : Integer) : Sequence(T)</tt></li> |
| * operation. |
| * |
| * @param self the source sequence |
| * @param lower the 1-based (in OCL fashion) inclusive lower bound |
| * @param upper the 1-based (in OCL fashion) inclusive upper bound |
| * @return the source collection with the object inserted at the index |
| * |
| * @throws IndexOutOfBoundsException if an index is out of bounds |
| * @throws IllegalArgumentException if the lower bound is greater than the upper |
| */ |
| public static <E> Collection<E> subSequence(Collection<E> self, int lower, |
| int upper) { |
| lower = lower - 1; |
| upper = upper - 1; |
| |
| if (lower < 0) { |
| throw new IndexOutOfBoundsException("lower: " + (lower + 1)); //$NON-NLS-1$ |
| } else if (upper >= self.size()) { |
| throw new IndexOutOfBoundsException( |
| "upper: " + (upper + 1) + ", size: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + self.size()); |
| } else if (upper < lower) { |
| throw new IllegalArgumentException( |
| "lower: " + (lower + 1) + ", upper: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + (upper + 1)); |
| } |
| |
| Collection<E> result = createNewSequence(); |
| int curr = 0; |
| for (Iterator<E> it = self.iterator(); it.hasNext();) { |
| E object = it.next(); |
| if (curr >= lower && curr <= upper) { |
| result.add(object); |
| } |
| curr++; |
| } |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::at(index : Integer) : T</tt></li> |
| * <li><tt>Sequence::at(index : Integer) : T</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param index the 1-based (in OCL fashion) index |
| * @return the object at the specified index of the source collection |
| * |
| * @throws IndexOutOfBoundsException if the index is out of bounds |
| */ |
| public static <E> E at(Collection<E> self, int index) { |
| index = index - 1; |
| |
| if (index < 0 || index >= self.size()) { |
| throw new IndexOutOfBoundsException( |
| "index: " + (index + 1) + ", size: " //$NON-NLS-1$ //$NON-NLS-2$ |
| + self.size()); |
| } |
| |
| int curr = 0; |
| for (Iterator<E> it = self.iterator(); it.hasNext();) { |
| E object = it.next(); |
| if (curr++ == index) { |
| return object; |
| } |
| } |
| return null; // undefined |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::first() : T</tt></li> |
| * <li><tt>Sequence::first() : T</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the first object of the source collection |
| */ |
| public static <E> E first(Collection<E> self) { |
| if (self.isEmpty()) { |
| return null; // undefined |
| } |
| return self.iterator().next(); |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::lset() : T</tt></li> |
| * <li><tt>Sequence::lset() : T</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @return the last object in the source collection |
| */ |
| public static <E> E last(Collection<E> self) { |
| if (self.isEmpty()) { |
| return null; // undefined |
| } |
| E result = null; |
| for (E next : self) { |
| result = next; |
| } |
| return result; |
| } |
| |
| /** |
| * Implementation of the OCL |
| * <ul> |
| * <li><tt>OrderedSet::indexOf(object : T) : Integer</tt></li> |
| * <li><tt>Sequence::indexOf(object : T) : Integer</tt></li> |
| * </ul> |
| * operations. |
| * |
| * @param self the source collection |
| * @param object an object |
| * @return the index of the object in the source collection |
| */ |
| public static <E> Integer indexOf(Collection<? extends E> self, E object) { |
| int index = 1; |
| |
| for (E next : self) { |
| if (ObjectUtil.equal(object, next)) { |
| return index; |
| } |
| index++; |
| } |
| |
| return null; // invalid |
| } |
| |
| /** |
| * Creates a new OCL <tt>Set</tt>. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> Set<E> createNewSet() { |
| return (Set<E>) createNewCollection(CollectionKind.SET_LITERAL); |
| } |
| |
| /** |
| * Creates a new OCL <tt>Set</tt> with initial contents supplied. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> Set<E> createNewSet(Collection<? extends E> c) { |
| return (Set<E>) createNewCollection(CollectionKind.SET_LITERAL, c); |
| } |
| |
| /** |
| * Creates a new OCL <tt>Bag</tt>. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> Bag<E> createNewBag() { |
| return (Bag<E>) createNewCollection(CollectionKind.BAG_LITERAL); |
| } |
| |
| /** |
| * Creates a new OCL <tt>Bag</tt> with initial contents supplied. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> Bag<E> createNewBag(Collection<? extends E> c) { |
| return (Bag<E>) createNewCollection(CollectionKind.BAG_LITERAL, c); |
| } |
| |
| /** |
| * Creates a new OCL <tt>OrderedSet</tt>. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> LinkedHashSet<E> createNewOrderedSet() { |
| return (LinkedHashSet<E>) createNewCollection( |
| CollectionKind.ORDERED_SET_LITERAL); |
| } |
| |
| /** |
| * Creates a new OCL <tt>OrderedSet</tt> with initial contents supplied. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> LinkedHashSet<E> createNewOrderedSet(Collection<? extends E> c) { |
| return (LinkedHashSet<E>) createNewCollection( |
| CollectionKind.ORDERED_SET_LITERAL, c); |
| } |
| |
| /** |
| * Creates a new OCL <tt>Sequence</tt>. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> List<E> createNewSequence() { |
| return (List<E>) createNewCollection(CollectionKind.SEQUENCE_LITERAL); |
| } |
| |
| /** |
| * Creates a new OCL <tt>Sequence</tt> with initial contents supplied. |
| */ |
| @SuppressWarnings("unchecked") |
| public static <E> List<E> createNewSequence(Collection<? extends E> c) { |
| return (List<E>) createNewCollection(CollectionKind.SEQUENCE_LITERAL, c); |
| } |
| |
| /** |
| * Creates a new, empty OCL collection of the same kind as the specified |
| * prototype. |
| * |
| * @param c a collection |
| * @return a new, empty collection of the same kind as <code>c</code> |
| */ |
| public static <E> Collection<E> createNewCollectionOfSameKind(Collection<?> c) { |
| Collection<E> result; |
| |
| if (c instanceof Bag<?>) { |
| result = createNewBag(); |
| } else if (c instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(); |
| } else if (c instanceof Set<?>) { |
| result = createNewSet(); |
| } else { |
| result = createNewSequence(); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Creates a new OCL collection of the same kind and contents as the |
| * specified prototype. |
| * |
| * @param c a collection |
| * @return a copy of <code>c</code> |
| */ |
| public static <E> Collection<E> createNewCollection(Collection<? extends E> c) { |
| Collection<E> result; |
| |
| if (c instanceof Bag<?>) { |
| result = createNewBag(c); |
| } else if (c instanceof LinkedHashSet<?>) { |
| result = createNewOrderedSet(c); |
| } else if (c instanceof Set<?>) { |
| result = createNewSet(c); |
| } else { |
| result = createNewSequence(c); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Creates a new OCL <tt>Collection</tt> of the specified kind. |
| * |
| * @param kind the OCL collection kind |
| * @return the new collection |
| */ |
| public static <E> Collection<E> createNewCollection(CollectionKind kind) { |
| switch (kind) { |
| case SET_LITERAL: |
| return new HashSet<E>(); |
| case SEQUENCE_LITERAL: |
| return new ArrayList<E>(); |
| case ORDERED_SET_LITERAL: |
| return new LinkedHashSet<E>(); |
| case BAG_LITERAL: |
| return new BagImpl<E>(); |
| default: { |
| String message = OCLMessages.bind( |
| OCLMessages.OCLCollectionKindNotImpl_ERROR_, |
| kind); |
| IllegalArgumentException error = new IllegalArgumentException( |
| message); |
| OCLPlugin.throwing( |
| CollectionUtil.class, |
| "createNewCollection", error);//$NON-NLS-1$ |
| throw error; |
| |
| } |
| } |
| } |
| |
| /** |
| * Creates a new OCL <tt>Collection</tt> of the specified kind. |
| * |
| * @param kind the OCL collection kind |
| * @param c the contents of the new collection |
| * @return the new collection of the specified <code>kind</code>, containing |
| * the same elements as <code>c</code> |
| */ |
| public static <E> Collection<E> createNewCollection( |
| CollectionKind kind, Collection<E> c) { |
| switch (kind) { |
| case SET_LITERAL: |
| return new HashSet<E>(c); |
| case SEQUENCE_LITERAL: |
| return new ArrayList<E>(c); |
| case BAG_LITERAL: |
| return new BagImpl<E>(c); |
| case ORDERED_SET_LITERAL: |
| return new LinkedHashSet<E>(c); |
| default: { |
| String message = OCLMessages.bind( |
| OCLMessages.OCLCollectionKindNotImpl_ERROR_, |
| kind); |
| IllegalArgumentException error = new IllegalArgumentException( |
| message); |
| OCLPlugin.throwing( |
| CollectionUtil.class, |
| "createNewCollection", error);//$NON-NLS-1$ |
| throw error; |
| } |
| } |
| } |
| |
| /** |
| * Infers the OCL kind of a collection. |
| * |
| * @param c a collection (not <code>null</code>) |
| * |
| * @return its kind (likewise, not <code>null</code>) |
| */ |
| private static CollectionKind kindOf(Collection<?> c) { |
| CollectionKind result; |
| |
| if (c instanceof List<?>){ |
| result = CollectionKind.SEQUENCE_LITERAL; |
| } else if (c instanceof LinkedHashSet<?>) { |
| result = CollectionKind.ORDERED_SET_LITERAL; |
| } else if (c instanceof Set<?>) { |
| result = CollectionKind.SET_LITERAL; |
| } else if (c instanceof Bag<?>) { |
| result = CollectionKind.BAG_LITERAL; |
| } else { |
| result = CollectionKind.COLLECTION_LITERAL; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Computes the string representation of a collection value using syntax |
| * like OCL's collection literals (e.g., <tt>OrderedSet{...}</tt>) instead |
| * of Java's default (i.e., <tt>[...]</tt>). |
| * |
| * @param c a collection (not <code>null</code>) |
| * @return the string representation of the specified collection |
| * |
| * @since 1.2 |
| */ |
| public static String toString(Collection<?> c) { |
| StringBuilder result = new StringBuilder(); |
| |
| result.append(kindOf(c).getName()); |
| result.append('{'); |
| |
| boolean notFirst = false; |
| for (Iterator<?> iter = c.iterator();;) { |
| if (iter.hasNext()) { |
| if (notFirst) { |
| result.append(", "); //$NON-NLS-1$ |
| } else { |
| notFirst = true; |
| } |
| |
| Object next = iter.next(); |
| if (next instanceof Collection<?>) { |
| // nested collection |
| result.append(toString((Collection<?>) next)); |
| } else if (next instanceof String) { |
| // string literal |
| result.append('\'').append(next).append('\''); |
| } else { |
| result.append(next); |
| } |
| } else { |
| break; |
| } |
| } |
| |
| result.append('}'); |
| |
| return result.toString(); |
| } |
| } |
