functional: remove now unused Iterables methods
Project: http://git-wip-us.apache.org/repos/asf/zest-java/repo Commit: http://git-wip-us.apache.org/repos/asf/zest-java/commit/0f956c80 Tree: http://git-wip-us.apache.org/repos/asf/zest-java/tree/0f956c80 Diff: http://git-wip-us.apache.org/repos/asf/zest-java/diff/0f956c80 Branch: refs/heads/develop Commit: 0f956c805b43d4d9e1e99989b3e51fd086971d00 Parents: a6ba8b5 Author: Paul Merlin <[email protected]> Authored: Tue Dec 6 19:37:12 2016 +0100 Committer: Paul Merlin <[email protected]> Committed: Tue Dec 6 19:40:30 2016 +0100 ---------------------------------------------------------------------- .../org/apache/zest/functional/Iterables.java | 559 +------------------ .../apache/zest/functional/IterablesTest.java | 117 +--- 2 files changed, 8 insertions(+), 668 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/zest-java/blob/0f956c80/core/functional/src/main/java/org/apache/zest/functional/Iterables.java ---------------------------------------------------------------------- diff --git a/core/functional/src/main/java/org/apache/zest/functional/Iterables.java b/core/functional/src/main/java/org/apache/zest/functional/Iterables.java index 8ecc9fb..0cdcd63 100644 --- a/core/functional/src/main/java/org/apache/zest/functional/Iterables.java +++ b/core/functional/src/main/java/org/apache/zest/functional/Iterables.java @@ -20,18 +20,11 @@ package org.apache.zest.functional; import java.lang.reflect.Array; -import java.text.MessageFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.Enumeration; -import java.util.HashSet; import java.util.Iterator; import java.util.List; -import java.util.NoSuchElementException; -import java.util.Set; import java.util.function.Function; import java.util.function.Predicate; @@ -40,128 +33,7 @@ import java.util.function.Predicate; */ public final class Iterables { - @SuppressWarnings( "raw" ) - private static final Iterable EMPTY = new Iterable() - { - Iterator iterator = new Iterator() - { - @Override - public boolean hasNext() - { - return false; - } - - @Override - public Object next() - { - throw new NoSuchElementException(); - } - - @Override - public void remove() - { - } - }; - - @Override - public Iterator iterator() - { - return iterator; - } - }; - - @SuppressWarnings( "unchecked" ) - public static <T> Iterable<T> empty() - { - return EMPTY; - } - - public static <T> Iterable<T> limit( final int limitItems, final Iterable<T> iterable ) - { - return new Iterable<T>() - { - @Override - public Iterator<T> iterator() - { - final Iterator<T> iterator = iterable.iterator(); - - return new Iterator<T>() - { - int count; - - @Override - public boolean hasNext() - { - return count < limitItems && iterator.hasNext(); - } - - @Override - public T next() - { - count++; - return iterator.next(); - } - - @Override - public void remove() - { - iterator.remove(); - } - }; - } - }; - } - - public static <T> Iterable<T> unique( final Iterable<T> iterable ) - { - return new Iterable<T>() - { - @Override - public Iterator<T> iterator() - { - final Iterator<T> iterator = iterable.iterator(); - - return new Iterator<T>() - { - private final Set<T> items = new HashSet<>(); - private T nextItem; - - @Override - public boolean hasNext() - { - while( iterator.hasNext() ) - { - nextItem = iterator.next(); - if( items.add( nextItem ) ) - { - return true; - } - } - - return false; - } - - @Override - public T next() - { - if( nextItem == null && !hasNext() ) - { - throw new NoSuchElementException(); - } - - return nextItem; - } - - @Override - public void remove() - { - } - }; - } - }; - } - - public static <T, C extends Collection<T>> C addAll( C collection, Iterable<? extends T> iterable ) + private static <T, C extends Collection<T>> C addAll( C collection, Iterable<? extends T> iterable ) { for( T item : iterable ) { @@ -199,52 +71,6 @@ public final class Iterables } } - public static <X> X single( Iterable<X> i ) - { - Iterator<X> iter = i.iterator(); - if( iter.hasNext() ) - { - X result = iter.next(); - - if( iter.hasNext() ) - { - throw new IllegalArgumentException( "More than one element in iterable" ); - } - - return result; - } - else - { - throw new IllegalArgumentException( "No elements in iterable" ); - } - } - - public static <X> Iterable<X> skip( final int skip, final Iterable<X> iterable ) - { - return new Iterable<X>() - { - @Override - public Iterator<X> iterator() - { - Iterator<X> iterator = iterable.iterator(); - - for( int i = 0; i < skip; i++ ) - { - if( iterator.hasNext() ) - { - iterator.next(); - } - else - { - return Iterables.<X>empty().iterator(); - } - } - - return iterator; - } - }; - } - public static <X> X last( Iterable<X> i ) { Iterator<X> iter = i.iterator(); @@ -257,176 +83,18 @@ public final class Iterables return item; } - public static <X> Iterable<X> reverse( Iterable<X> iterable ) - { - List<X> list = toList( iterable ); - Collections.reverse( list ); - return list; - } - - public static <T> boolean matchesAny( Predicate<? super T> specification, Iterable<T> iterable ) - { - boolean result = false; - - for( T item : iterable ) - { - if( ( (Predicate<? super T>) specification ).test( item ) ) - { - result = true; - break; - } - } - - return result; - } - - public static <T> boolean matchesAll( Predicate<? super T> specification, Iterable<T> iterable ) - { - boolean result = true; - for( T item : iterable ) - { - if( !specification.test( item ) ) - { - result = false; - } - } - - return result; - } - - public static <X> Iterable<X> flatten( Iterable<?>... multiIterator ) - { - return new FlattenIterable<>( Iterables.<Iterable<X>>cast( Arrays.asList( multiIterator ) ) ); - } - - public static <X, I extends Iterable<? extends X>> Iterable<X> flattenIterables( Iterable<I> multiIterator ) - // public static <X> Iterable<X> flattenIterables( Iterable<Iterable<?>> multiIterator ) - { - return new FlattenIterable<>( Iterables.<Iterable<X>>cast( multiIterator ) ); - } - - @SafeVarargs - public static <T> Iterable<T> mix( final Iterable<T>... iterables ) - { - return new Iterable<T>() - { - @Override - public Iterator<T> iterator() - { - final Iterable<Iterator<T>> iterators = toList( map( new Function<Iterable<T>, Iterator<T>>() - { - @Override - public Iterator<T> apply( Iterable<T> iterable ) - { - return iterable.iterator(); - } - }, Iterables.iterable( iterables ) ) ); - - return new Iterator<T>() - { - Iterator<Iterator<T>> iterator; - - Iterator<T> iter; - - @Override - public boolean hasNext() - { - for( Iterator<T> iterator : iterators ) - { - if( iterator.hasNext() ) - { - return true; - } - } - - return false; - } - - @Override - public T next() - { - if( iterator == null ) - { - iterator = iterators.iterator(); - } - - while( iterator.hasNext() ) - { - iter = iterator.next(); - - if( iter.hasNext() ) - { - return iter.next(); - } - } - - iterator = null; - - return next(); - } - - @Override - public void remove() - { - if( iter != null ) - { - iter.remove(); - } - } - }; - } - }; - } - @SuppressWarnings( "unchecked" ) public static <FROM, TO> Iterable<TO> map( Function<? /* super FROM */, TO> function, Iterable<FROM> from ) { return new MapIterable<>( from, (Function<FROM, TO>) function ); } - public static <T> Iterable<T> iterable( Enumeration<T> enumeration ) - { - List<T> list = new ArrayList<>(); - while( enumeration.hasMoreElements() ) - { - T item = enumeration.nextElement(); - list.add( item ); - } - - return list; - } - @SafeVarargs public static <T> Iterable<T> iterable( T... items ) { return Arrays.asList( items ); } - @SuppressWarnings( {"raw", "unchecked"} ) - public static <T> Iterable<T> cast( Iterable<?> iterable ) - { - Iterable iter = iterable; - return iter; - } - - public static <FROM, TO> Function<FROM, TO> cast() - { - return new Function<FROM, TO>() - { - @Override - @SuppressWarnings( "unchecked" ) - public TO apply( FROM from ) - { - return (TO) from; - } - }; - } - - public static <FROM, TO> TO fold( Function<? super FROM, TO> function, Iterable<? extends FROM> i ) - { - return last( map( function, i ) ); - } - public static <T> Iterable<T> prepend( final T item, final Iterable<T> iterable ) { return () -> new Iterator<T>() @@ -495,14 +163,7 @@ public final class Iterables @Override public boolean hasNext() { - if( iterator.hasNext() ) - { - return true; - } - else - { - return last != null; - } + return iterator.hasNext() || last != null; } @Override @@ -534,74 +195,9 @@ public final class Iterables }; } - @SafeVarargs - public static <T> Iterable<T> debug( String format, - final Iterable<T> iterable, - final Function<T, String>... functions - ) - { - final MessageFormat msgFormat = new MessageFormat( format ); - - return map( new Function<T, T>() - { - @Override - public T apply( T t ) - { - if( functions.length != 0 ) - { - String[] mapped = new String[ functions.length ]; - for( int i = 0; i < functions.length; i++ ) - { - Function<T, String> function = functions[ i ]; - mapped[ i ] = function.apply( t ); - } - } - return t; - } - }, iterable ); - } - - public static <T> Iterable<T> cache( Iterable<T> iterable ) - { - return new CacheIterable<>( iterable ); - } - - public static <T> String toString( Iterable<T> iterable ) - { - return toString( iterable, new Function<T, String>() - { - @Override - public String apply( T t ) - { - return t == null ? "[null]" : t.toString(); - } - }, "," ); - } - - public static <T> String toString( Iterable<T> iterable, Function<T, String> toStringFunction, String separator ) - { - StringBuilder builder = new StringBuilder(); - boolean first = true; - for( T item : iterable ) - { - if( !first ) - { - builder.append( separator ); - } - builder.append( toStringFunction.apply( item ) ); - first = false; - } - return builder.toString(); - } - public static <T> List<T> toList( Iterable<T> iterable ) { - return addAll( new ArrayList<T>(), iterable ); - } - - public static Object[] toArray( Iterable<Object> iterable ) - { - return toArray( Object.class, iterable ); + return addAll( new ArrayList<>(), iterable ); } @SuppressWarnings( "unchecked" ) @@ -615,21 +211,6 @@ public final class Iterables return list.toArray( (T[]) Array.newInstance( componentType, list.size() ) ); } - @SuppressWarnings( {"raw", "unchecked"} ) - public static <X extends Comparable> Iterable<X> sort( Iterable<X> iterable ) - { - List<X> list = toList( iterable ); - Collections.sort( list ); - return list; - } - - public static <X> Iterable<X> sort( Comparator<? super X> comparator, Iterable<X> iterable ) - { - List<X> list = toList( iterable ); - Collections.sort( list, comparator ); - return list; - } - private static class MapIterable<FROM, TO> implements Iterable<TO> { @@ -679,7 +260,6 @@ public final class Iterables fromIterator.remove(); } } - } private static class FilterIterable<T> @@ -718,7 +298,7 @@ public final class Iterables this.iterator = iterator; } - public boolean moveToNextValid() + private boolean moveToNextValid() { boolean found = false; while( !found && iterator.hasNext() ) @@ -765,146 +345,17 @@ public final class Iterables @Override public boolean hasNext() { - return !finished - && ( !nextConsumed || moveToNextValid() ); - } - - @Override - public void remove() - { - } - } - - } - - private static class FlattenIterable<T, I extends Iterable<? extends T>> - implements Iterable<T> - { - private final Iterable<I> iterable; - - private FlattenIterable( Iterable<I> iterable ) - { - this.iterable = iterable; - } - - @Override - public Iterator<T> iterator() - { - return new FlattenIterator<>( iterable.iterator() ); - } - - static class FlattenIterator<T, I extends Iterable<? extends T>> - implements Iterator<T> - { - private final Iterator<I> iterator; - private Iterator<? extends T> currentIterator; - - private FlattenIterator( Iterator<I> iterator ) - { - this.iterator = iterator; - currentIterator = null; - } - - @Override - public boolean hasNext() - { - if( currentIterator == null ) - { - if( iterator.hasNext() ) - { - I next = iterator.next(); - currentIterator = next.iterator(); - } - else - { - return false; - } - } - - while( !currentIterator.hasNext() - && iterator.hasNext() ) - { - currentIterator = iterator.next().iterator(); - } - - return currentIterator.hasNext(); - } - - @Override - public T next() - { - return currentIterator.next(); + return !finished && ( !nextConsumed || moveToNextValid() ); } @Override public void remove() { - if( currentIterator == null ) - { - throw new IllegalStateException(); - } - - currentIterator.remove(); - } - } - - } - - private static class CacheIterable<T> - implements Iterable<T> - { - private final Iterable<T> iterable; - private Iterable<T> cache; - - private CacheIterable( Iterable<T> iterable ) - { - this.iterable = iterable; - } - - @Override - public Iterator<T> iterator() - { - if( cache != null ) - { - return cache.iterator(); } - - final Iterator<T> source = iterable.iterator(); - - return new Iterator<T>() - { - List<T> iteratorCache = new ArrayList<>(); - - @Override - public boolean hasNext() - { - boolean hasNext = source.hasNext(); - if( !hasNext ) - { - cache = iteratorCache; - } - return hasNext; - } - - @Override - public T next() - { - T next = source.next(); - iteratorCache.add( next ); - return next; - } - - @Override - public void remove() - { - - } - }; } } private Iterables() { } - } http://git-wip-us.apache.org/repos/asf/zest-java/blob/0f956c80/core/functional/src/test/java/org/apache/zest/functional/IterablesTest.java ---------------------------------------------------------------------- diff --git a/core/functional/src/test/java/org/apache/zest/functional/IterablesTest.java b/core/functional/src/test/java/org/apache/zest/functional/IterablesTest.java index b8376c8..84787d7 100644 --- a/core/functional/src/test/java/org/apache/zest/functional/IterablesTest.java +++ b/core/functional/src/test/java/org/apache/zest/functional/IterablesTest.java @@ -21,15 +21,13 @@ package org.apache.zest.functional; import java.util.Arrays; import java.util.Collection; -import java.util.Comparator; -import java.util.Enumeration; import java.util.List; import java.util.function.Function; -import org.hamcrest.CoreMatchers; import org.junit.Test; -import static java.util.Collections.*; -import static org.hamcrest.CoreMatchers.*; +import static java.util.Collections.emptyList; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.nullValue; import static org.junit.Assert.assertThat; /** @@ -37,22 +35,8 @@ import static org.junit.Assert.assertThat; */ public class IterablesTest { - private List<String> numbers = Arrays.asList( "1", "2", "3" ); private Iterable<Long> numberLongs = Arrays.asList( 1L, 2L, 3L ); - private Iterable<Integer> numberIntegers = Arrays.asList( 1, 2, 3 ); - - @Test - public void testUnique() - { - String str = ""; - - for( String string : Iterables.unique( Iterables.<String>flatten( numbers, numbers, numbers ) ) ) - { - str += string; - } - assertThat( str, CoreMatchers.equalTo( "123" ) ); - } @Test public void testAddAll() @@ -76,30 +60,6 @@ public class IterablesTest } @Test - public void testLast() - { - assertThat( Iterables.last( numbers ), equalTo( "3" ) ); - assertThat( Iterables.last( emptyList() ), nullValue() ); - } - - @Test - public void testFolding() - { - assertThat( Iterables.fold( new Function<Integer, Integer>() - { - - int sum = 0; - - @Override - public Integer apply( Integer number ) - { - return sum += number; - } - - }, numberIntegers ), equalTo( 6 ) ); - } - - @Test public void testAppend() { assertThat( Iterables.toList( Iterables.append( "C", Iterables.iterable( "A", "B" ) ) ).toString(), @@ -107,40 +67,6 @@ public class IterablesTest } @Test - public void testReverse() - { - assertThat( Iterables.reverse( numbers ).toString(), equalTo( "[3, 2, 1]" ) ); - assertThat( Iterables.reverse( emptyList() ), equalTo( (Object) emptyList() ) ); - } - - @Test - public void testFlatten() - { - assertThat( Iterables.toList( Iterables.flatten( numbers, numbers ) ).toString(), - equalTo( "[1, 2, 3, 1, 2, 3]" ) ); - - Iterable<? extends Number> flatten = Iterables.flatten( numberIntegers, numberLongs ); - assertThat( Iterables.toList( flatten ).toString(), equalTo( "[1, 2, 3, 1, 2, 3]" ) ); - } - - @Test - public void testFlattenIterables() - { - Iterable<List<String>> iterable = Iterables.iterable( numbers, numbers ); - assertThat( Iterables.toList( Iterables.flattenIterables( iterable ) ).toString(), - equalTo( "[1, 2, 3, 1, 2, 3]" ) ); - } - - @Test - public void testMix() - { - assertThat( Iterables.toList( Iterables.mix( Iterables.iterable( "A", "B", "C" ), - Iterables.iterable( "1", "2", "3", "4", "5" ), - Iterables.iterable( "X", "Y", "Z" ) ) ).toString(), - equalTo( "[A, 1, X, B, 2, Y, C, 3, Z, 4, 5]" ) ); - } - - @Test public void testMap() { assertThat( Iterables.toList( Iterables.map( new Function<String, String>() @@ -150,7 +76,6 @@ public class IterablesTest { return s + s; } - }, numbers ) ).toString(), equalTo( "[11, 22, 33]" ) ); Iterable<List<String>> numberIterable = Iterables.iterable( numbers, numbers, numbers ); @@ -162,49 +87,13 @@ public class IterablesTest { return collection.size(); } - }, numberIterable ) ).toString(), equalTo( "[3, 3, 3]" ) ); } @Test - public void testIterableEnumeration() - { - - Enumeration<String> enumeration = enumeration( numbers ); - assertThat( Iterables.toList( Iterables.iterable( enumeration ) ).toString(), - equalTo( "[1, 2, 3]" ) ); - } - - @Test public void testIterableVarArg() { assertThat( Iterables.toList( Iterables.iterable( "1", "2", "3" ) ).toString(), equalTo( "[1, 2, 3]" ) ); } - - @Test - public void testCast() - { - Iterable<Long> values = numberLongs; - Iterable<Number> numbers = Iterables.cast( values ); - } - - @Test - public void testSort() - { - assertThat( Iterables.sort( Iterables.reverse( numberLongs ) ).toString(), equalTo( "[1, 2, 3]" ) ); - - Comparator<Long> inverseLongComparator = new Comparator<Long>() - { - - @Override - public int compare( Long left, Long right ) - { - return left.compareTo( right ) * -1; - } - - }; - assertThat( Iterables.sort( inverseLongComparator, numberLongs ).toString(), equalTo( "[3, 2, 1]" ) ); - } - }
