From ebf96a30d0122d35e271bad15f1f31a0a9100842 Mon Sep 17 00:00:00 2001
From: Ludovic Poitou <ludovic.poitou@forgerock.com>
Date: Sun, 24 Oct 2010 20:47:53 +0000
Subject: [PATCH] Sync commits from OpenDS by matthew_swift
---
sdk/src/com/sun/opends/sdk/util/Collections2.java | 319 +++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 299 insertions(+), 20 deletions(-)
diff --git a/sdk/src/com/sun/opends/sdk/util/Collections2.java b/sdk/src/com/sun/opends/sdk/util/Collections2.java
index 27a7724..fd54426 100644
--- a/sdk/src/com/sun/opends/sdk/util/Collections2.java
+++ b/sdk/src/com/sun/opends/sdk/util/Collections2.java
@@ -22,16 +22,14 @@
* CDDL HEADER END
*
*
- * Copyright 2009 Sun Microsystems, Inc.
+ * Copyright 2009-2010 Sun Microsystems, Inc.
*/
package com.sun.opends.sdk.util;
-import java.util.AbstractCollection;
-import java.util.Collection;
-import java.util.Iterator;
+import java.util.*;
@@ -40,21 +38,21 @@
*/
public final class Collections2
{
- private static final class TransformedCollection<M, N, P> extends
- AbstractCollection<N> implements Collection<N>
+ private static class TransformedCollection<M, N, P, C extends Collection<M>>
+ extends AbstractCollection<N> implements Collection<N>
{
- private final Collection<M> collection;
+ protected final C collection;
- private final Function<? super M, ? extends N, P> funcMtoN;
+ protected final Function<? super M, ? extends N, P> funcMtoN;
- private final Function<? super N, ? extends M, P> funcNtoM;
+ protected final Function<? super N, ? extends M, P> funcNtoM;
- private final P p;
+ protected final P p;
- private TransformedCollection(final Collection<M> collection,
+ protected TransformedCollection(final C collection,
final Function<? super M, ? extends N, P> funcMtoN,
final Function<? super N, ? extends M, P> funcNtoM, final P p)
{
@@ -118,7 +116,7 @@
@Override
public Iterator<N> iterator()
{
- return Iterators.transform(collection.iterator(), funcMtoN, p);
+ return Iterators.transformedIterator(collection.iterator(), funcMtoN, p);
}
@@ -149,6 +147,217 @@
+ private static final class TransformedList<M, N, P> extends
+ TransformedCollection<M, N, P, List<M>> implements List<N>
+ {
+
+ private TransformedList(final List<M> list,
+ final Function<? super M, ? extends N, P> funcMtoN,
+ final Function<? super N, ? extends M, P> funcNtoM, final P p)
+ {
+ super(list, funcMtoN, funcNtoM, p);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void add(final int index, final N element)
+ {
+ collection.add(index, funcNtoM.apply(element, p));
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean addAll(final int index, final Collection<? extends N> c)
+ {
+ // We cannot transform c here due to type-safety.
+ boolean result = false;
+ for (final N e : c)
+ {
+ result |= add(e);
+ }
+ return result;
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public N get(final int index)
+ {
+ return funcMtoN.apply(collection.get(index), p);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("unchecked")
+ public int indexOf(final Object o)
+ {
+ final N tmp = (N) o;
+ return collection.indexOf(funcNtoM.apply(tmp, p));
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ @SuppressWarnings("unchecked")
+ public int lastIndexOf(final Object o)
+ {
+ final N tmp = (N) o;
+ return collection.lastIndexOf(funcNtoM.apply(tmp, p));
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public ListIterator<N> listIterator()
+ {
+ return listIterator(0);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public ListIterator<N> listIterator(final int index)
+ {
+ final ListIterator<M> iterator = collection.listIterator(index);
+ return new ListIterator<N>()
+ {
+
+ @Override
+ public void add(final N e)
+ {
+ iterator.add(funcNtoM.apply(e, p));
+ }
+
+
+
+ @Override
+ public boolean hasNext()
+ {
+ return iterator.hasNext();
+ }
+
+
+
+ @Override
+ public boolean hasPrevious()
+ {
+ return iterator.hasPrevious();
+ }
+
+
+
+ @Override
+ public N next()
+ {
+ return funcMtoN.apply(iterator.next(), p);
+ }
+
+
+
+ @Override
+ public int nextIndex()
+ {
+ return iterator.nextIndex();
+ }
+
+
+
+ @Override
+ public N previous()
+ {
+ return funcMtoN.apply(iterator.previous(), p);
+ }
+
+
+
+ @Override
+ public int previousIndex()
+ {
+ return iterator.previousIndex();
+ }
+
+
+
+ @Override
+ public void remove()
+ {
+ iterator.remove();
+ }
+
+
+
+ @Override
+ public void set(final N e)
+ {
+ iterator.set(funcNtoM.apply(e, p));
+ }
+
+ };
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public N remove(final int index)
+ {
+ return funcMtoN.apply(collection.remove(index), p);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public N set(final int index, final N element)
+ {
+ final M result = collection.set(index, funcNtoM.apply(element, p));
+ return funcMtoN.apply(result, p);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List<N> subList(final int fromIndex, final int toIndex)
+ {
+ final List<M> subList = collection.subList(fromIndex, toIndex);
+ return new TransformedList<M, N, P>(subList, funcMtoN, funcNtoM, p);
+ }
+
+ }
+
+
+
/**
* Returns a view of {@code collection} whose values have been mapped to
* elements of type {@code N} using {@code funcMtoN}. The returned collection
@@ -159,9 +368,9 @@
* @param <N>
* The type of elements contained in the returned collection.
* @param <P>
- * The type of the additional parameter to the function's {@code
- * apply} method. Use {@link java.lang.Void} for functions that do
- * not need an additional parameter.
+ * The type of the additional parameter to the function's
+ * {@code apply} method. Use {@link java.lang.Void} for functions
+ * that do not need an additional parameter.
* @param collection
* The collection to be transformed.
* @param funcMtoN
@@ -177,12 +386,13 @@
* @return A view of {@code collection} whose values have been mapped to
* elements of type {@code N} using {@code funcMtoN}.
*/
- public static <M, N, P> Collection<N> transform(
+ public static <M, N, P> Collection<N> transformedCollection(
final Collection<M> collection,
final Function<? super M, ? extends N, P> funcMtoN,
final Function<? super N, ? extends M, P> funcNtoM, final P p)
{
- return new TransformedCollection<M, N, P>(collection, funcMtoN, funcNtoM, p);
+ return new TransformedCollection<M, N, P, Collection<M>>(collection,
+ funcMtoN, funcNtoM, p);
}
@@ -209,12 +419,81 @@
* @return A view of {@code collection} whose values have been mapped to
* elements of type {@code N} using {@code funcMtoN}.
*/
- public static <M, N> Collection<N> transform(final Collection<M> collection,
+ public static <M, N> Collection<N> transformedCollection(
+ final Collection<M> collection,
final Function<? super M, ? extends N, Void> funcMtoN,
final Function<? super N, ? extends M, Void> funcNtoM)
{
- return new TransformedCollection<M, N, Void>(collection, funcMtoN,
- funcNtoM, null);
+ return new TransformedCollection<M, N, Void, Collection<M>>(collection,
+ funcMtoN, funcNtoM, null);
+ }
+
+
+
+ /**
+ * Returns a view of {@code list} whose values have been mapped to elements of
+ * type {@code N} using {@code funcMtoN}. The returned list supports all
+ * operations.
+ *
+ * @param <M>
+ * The type of elements contained in {@code list}.
+ * @param <N>
+ * The type of elements contained in the returned list.
+ * @param <P>
+ * The type of the additional parameter to the function's
+ * {@code apply} method. Use {@link java.lang.Void} for functions
+ * that do not need an additional parameter.
+ * @param list
+ * The list to be transformed.
+ * @param funcMtoN
+ * A function which maps values of type {@code M} to values of type
+ * {@code N}. This function will be used when retrieving values from
+ * {@code list}.
+ * @param funcNtoM
+ * A function which maps values of type {@code N} to values of type
+ * {@code M}. This function will be used when performing queries and
+ * adding values to {@code list} .
+ * @param p
+ * A predicate specified parameter.
+ * @return A view of {@code list} whose values have been mapped to elements of
+ * type {@code N} using {@code funcMtoN}.
+ */
+ public static <M, N, P> List<N> transformedList(final List<M> list,
+ final Function<? super M, ? extends N, P> funcMtoN,
+ final Function<? super N, ? extends M, P> funcNtoM, final P p)
+ {
+ return new TransformedList<M, N, P>(list, funcMtoN, funcNtoM, p);
+ }
+
+
+
+ /**
+ * Returns a view of {@code list} whose values have been mapped to elements of
+ * type {@code N} using {@code funcMtoN}. The returned list supports all
+ * operations.
+ *
+ * @param <M>
+ * The type of elements contained in {@code list}.
+ * @param <N>
+ * The type of elements contained in the returned list.
+ * @param list
+ * The list to be transformed.
+ * @param funcMtoN
+ * A function which maps values of type {@code M} to values of type
+ * {@code N}. This function will be used when retrieving values from
+ * {@code list}.
+ * @param funcNtoM
+ * A function which maps values of type {@code N} to values of type
+ * {@code M}. This function will be used when performing queries and
+ * adding values to {@code list} .
+ * @return A view of {@code list} whose values have been mapped to elements of
+ * type {@code N} using {@code funcMtoN}.
+ */
+ public static <M, N> List<N> transformedList(final List<M> list,
+ final Function<? super M, ? extends N, Void> funcMtoN,
+ final Function<? super N, ? extends M, Void> funcNtoM)
+ {
+ return new TransformedList<M, N, Void>(list, funcMtoN, funcNtoM, null);
}
--
Gitblit v1.10.0