be.bagofwords.iterator.IterableUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bow-utils Show documentation
Utility classes that are used in the count-db project and other bow-* projects
There is a newer version: 1.2.0
package be.bagofwords.iterator;

import java.util.*;

public class IterableUtils {

    public static  DataIterable createIterable(final DataIterable... iterables) {
        return createIterable(CombineMethod.SEQUENTIAL, iterables);
    }

    public static  DataIterable createIterable(CombineMethod combineMethod, final DataIterable... iterables) {
        return createIterable(combineMethod, Arrays.asList(iterables));
    }

    public static  DataIterable createIterable(final List> iterables) {
        return createIterable(CombineMethod.SEQUENTIAL, iterables);
    }

    public static  DataIterable createIterable(final Collection collection) {
        return new DataIterable() {
            @Override
            public CloseableIterator iterator() {
                return IterableUtils.iterator(collection.iterator());
            }

            @Override
            public long apprSize() {
                return collection.size();
            }
        };
    }

    public static  DataIterable createIterable(final CombineMethod combineMethod, final List> iterables) {
        return new DataIterable() {
            @Override
            public CloseableIterator iterator() {
                List> iterators = new ArrayList<>();
                for (DataIterable iterable : iterables) {
                    iterators.add(iterable.iterator());
                }
                if (combineMethod == CombineMethod.SEQUENTIAL) {
                    return new SequentialIteratorOfIterators<>(iterators);
                } else {
                    return new InterleavedIteratorOfIterators<>(iterators);
                }
            }

            @Override
            public long apprSize() {
                long result = 0;
                for (DataIterable iterable : iterables) {
                    result += iterable.apprSize();
                }
                return result;
            }
        };
    }

    public static  CloseableIterator iterator(final SimpleIterator simpleIt) {
        return iterator(simpleIt, null);
    }

    public static  CloseableIterator iterator(final SimpleIterator simpleIt, final T lastValue) {
        return new CloseableIterator() {

            private T nextValue;

            {
                findNext();
            }

            private void findNext() {
                try {
                    nextValue = simpleIt.next();
                    if (nextValue == null) {
                        if (lastValue == null) {
                            close();
                        }
                    } else {
                        if (lastValue != null && nextValue.equals(lastValue)) {
                            close();
                        }
                    }
                } catch (Exception e) {
                    throw new RuntimeException("Could not read next value ", e);
                }
            }

            @Override
            public boolean hasNext() {
                if (lastValue == null) {
                    return nextValue != null;
                } else {
                    return !lastValue.equals(nextValue);
                }
            }

            @Override
            public synchronized T next() {
                T result = nextValue;
                findNext();
                return result;
            }

            @Override
            public void remove() {
                throw new RuntimeException("Not implemented");
            }

            @Override
            public void closeInt() {
                synchronized (this) {
                    try {
                        simpleIt.close();
                    } catch (Exception e) {
                        throw new RuntimeException("Failed to close iterator", e);
                    }
                }
            }
        };
    }

    public static  CloseableIterator iterator(final Iterator iterator) {
        return new CloseableIterator() {
            @Override
            public void closeInt() {
                //do nothing
            }

            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }

            @Override
            public T next() {
                return iterator.next();
            }
        };
    }

    public static  CloseableIterator maxSizeIterator(final long maxIterations, final CloseableIterator iterator) {
        return new CloseableIterator() {

            private long numDone = 0;

            @Override
            protected void closeInt() {
                iterator.close();
            }

            @Override
            public boolean hasNext() {
                return iterator.hasNext() && numDone < maxIterations;
            }

            @Override
            public T next() {
                numDone++;
                return iterator.next();
            }
        };
    }

    public static  DataIterable maxSizeIterable(final long maxIterations, final DataIterable iterable) {
        if (maxIterations <= 0) {
            throw new RuntimeException("Incorrect number of iterations " + maxIterations);
        }
        return new DataIterable() {
            @Override
            public CloseableIterator iterator() {
                return maxSizeIterator(maxIterations, iterable.iterator());
            }

            @Override
            public long apprSize() {
                return Math.min(maxIterations, iterable.apprSize());
            }
        };
    }

    public static enum CombineMethod {
        SEQUENTIAL, INTERLEAVED
    }

}