/** * Factory method to create an ordered set. * <p> * An <code>ArrayList</code> is used to retain order. * * @param set the set to decorate, must not be null * @throws IllegalArgumentException if set is null */ public static ListOrderedSet decorate(Set set) { return new ListOrderedSet(set); }
public void testListAddRemove() { ListOrderedSet set = (ListOrderedSet) makeEmptySet(); List view = set.asList(); set.add(ZERO); set.add(ONE); set.add(TWO); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); assertEquals(3, view.size()); assertSame(ZERO, view.get(0)); assertSame(ONE, view.get(1)); assertSame(TWO, view.get(2)); assertEquals(0, set.indexOf(ZERO)); assertEquals(1, set.indexOf(ONE)); assertEquals(2, set.indexOf(TWO)); set.remove(1); assertEquals(2, set.size()); assertSame(ZERO, set.get(0)); assertSame(TWO, set.get(1)); assertEquals(2, view.size()); assertSame(ZERO, view.get(0)); assertSame(TWO, view.get(1)); }
/** * Returns a set that maintains the order of elements that are added * backed by the given set. * <p> * If an element is added twice, the order is determined by the first add. * The order is observed through the iterator or toArray. * * @param set the set to order, must not be null * @return an ordered set backed by the given set * @throws IllegalArgumentException if the Set is null */ public static Set orderedSet(Set set) { return ListOrderedSet.decorate(set); }
public void testListAddReplacing() { ListOrderedSet set = (ListOrderedSet) makeEmptySet(); A a = new A(); B b = new B(); set.add(a); assertEquals(1, set.size()); set.add(b); // will match but not replace A as equal assertEquals(1, set.size()); assertSame(a, set.getSet().iterator().next()); assertSame(a, set.iterator().next()); assertSame(a, set.get(0)); assertSame(a, set.asList().get(0)); }
public void testListAddIndexed() { ListOrderedSet set = (ListOrderedSet) makeEmptySet(); set.add(ZERO); set.add(TWO); set.add(1, ONE); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.add(0, ONE); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.addAll(0, list); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.remove(TWO); // set = [0,1] set.addAll(1, list); assertEquals(4, set.size()); assertSame(ZERO, set.get(0)); assertSame(THREE, set.get(1)); assertSame(TWO, set.get(2)); assertSame(ONE, set.get(3));
public boolean addAll(Collection coll) { boolean result = false; for (Iterator it = coll.iterator(); it.hasNext();) { Object object = it.next(); result = result | add(object); } return result; }
/** * {@inheritDoc} */ public Object clone() throws CloneNotSupportedException { ForeignKey result = (ForeignKey)super.clone(); result._name = _name; result._foreignTableName = _foreignTableName; result._references = new ListOrderedSet(); for (Iterator it = _references.iterator(); it.hasNext();) { result._references.add(((Reference)it.next()).clone()); } return result; }
public Object remove(int index) { Object obj = setOrder.remove(index); remove(obj); return obj; }
ListOrderedSet firstHashes = new ListOrderedSet(); ListOrderedSet secondHashes = new ListOrderedSet(); firstHashes.add(new MultiKey(member.getSubjectSourceId(), member.getSubjectId())); secondHashes.add(new MultiKey(subject.getSource().getId(), subject.getId())); while (firstIterator.hasNext()) { Member next = firstIterator.next(); MultiKey hash = (MultiKey)firstHashes.get(i); if (secondHashes.contains(hash)) { firstIterator.remove(); overlaps.add(next); int subjectIndex = secondHashes.indexOf(hash); Subject realSubject = second.get(subjectIndex); while (secondIterator.hasNext()) { secondIterator.next(); if (firstHashes.contains(secondHashes.get(i))) { secondIterator.remove();
private List<Locale> getAllowedLocalesList(JdbcConnection connection) { Statement stmt = null; ListOrderedSet allowedLocales = new ListOrderedSet(); allowedLocales.add(defaultLocale); for (String localeStr : localesArray) { if (localeStr.trim().length() > 1) { allowedLocales.add(LocaleUtility.fromSpecification(localeStr.trim())); } else { updateWarnings.add("'" + localeStr allowedLocales.add(new Locale("en")); return allowedLocales.asList();
/** * Determines the columns that are present in the given result set. * * @param resultSet The result set * @return The columns */ private Set getColumnsInResultSet(ResultSet resultSet) throws SQLException { ListOrderedSet result = new ListOrderedSet(); ResultSetMetaData metaData = resultSet.getMetaData(); for (int idx = 1; idx <= metaData.getColumnCount(); idx++) { result.add(metaData.getColumnName(idx).toUpperCase()); } return result; } }
public void add(int index, Object object) { if (contains(object) == false) { collection.add(object); setOrder.add(index, object); } }
/** * Removes the specified identity from list of identities of the waited-for objects. * * @param fkIdentity The identity to remove * @return The removed identity if any */ public Identity removePendingFK(Identity fkIdentity) { Identity result = null; int idx = _waitedForIdentites.indexOf(fkIdentity); if (idx >= 0) { result = (Identity)_waitedForIdentites.get(idx); _waitedForIdentites.remove(idx); } return result; }
/** * Adds a reference, ie. a mapping between a local column (in the table that owns this foreign key) * and a remote column. * * @param reference The reference to add */ public void addReference(Reference reference) { if (reference != null) { for (int idx = 0; idx < _references.size(); idx++) { Reference curRef = getReference(idx); if (curRef.getSequenceValue() > reference.getSequenceValue()) { _references.add(idx, reference); return; } } _references.add(reference); } }
@Override public String toString() { if (classes.isEmpty()) { return null; } final StringBuilder buffer = new StringBuilder(16 * classes.size()); for (final Iterator i = classes.iterator(); i.hasNext();) { final String clazz = (String) i.next(); buffer.append(clazz); if (i.hasNext()) { buffer.append(' '); } } return buffer.toString(); }
/** * Returns the identities of the object that this object is waiting for. * * @return The identities */ public Iterator getPendingFKs() { return _waitedForIdentites.iterator(); }
/** * Returns the indicated reference. * * @param idx The index * @return The reference */ public Reference getReference(int idx) { return (Reference)_references.get(idx); }
public void testListAddIndexed() { ListOrderedSet set = (ListOrderedSet) makeEmptySet(); List view = set.asList(); set.add(ZERO); set.add(TWO); set.add(1, ONE); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.add(0, ONE); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.addAll(0, list); assertEquals(3, set.size()); assertSame(ZERO, set.get(0)); assertSame(ONE, set.get(1)); assertSame(TWO, set.get(2)); set.remove(TWO); // set = [0,1] set.addAll(1, list); assertEquals(4, set.size()); assertSame(ZERO, set.get(0)); assertSame(THREE, set.get(1)); assertSame(TWO, set.get(2));
public boolean addAll(Collection coll) { boolean result = false; for (Iterator it = coll.iterator(); it.hasNext();) { Object object = it.next(); result = result | add(object); } return result; }