You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@polygene.apache.org by pa...@apache.org on 2016/12/08 23:44:12 UTC
[03/13] zest-java git commit: functional: remove now unused Iterables
methods
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 <pa...@apache.org>
Authored: Tue Dec 6 19:37:12 2016 +0100
Committer: Paul Merlin <pa...@apache.org>
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]" ) );
- }
-
}