org.rdfhdt.hdt.iterator.utils.Iter Maven / Gradle / Ivy

package org.rdfhdt.hdt.iterator.utils;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Iter {
	
	private Iter() {}

	public static  Iterable mapIterable(final Iterable iter1, final Transform converter) {
		return new Iterable() {
			@Override
			public Iterator iterator() {
				return Iter.map(iter1, converter);
			}
		};
	}


	public static  Iterator map(Iterable stream, Transform converter) {
		return map(stream.iterator(), converter) ;
	}

	public static  Iterator map(final Iterator stream, final Transform converter) {
		final Iterator iter = new Iterator() {
			@Override
			public boolean hasNext() {
				return stream.hasNext() ;
			}

			@Override
			public R next() {
				return converter.convert(stream.next()) ;
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException("map.remove") ;
			}
		} ;
		return iter ;
	}

	public static  Iterator dedup(Iterator it) {
		return new DedupIterator(it);
	}

	public static  Iterator filter(Iterable stream, Filter filter) {
		return filter(stream.iterator(), filter) ;
	}
	
	public static  Iterator filterNotEqual(final Iterator stream, final T sampleObject) {
		return filter(stream, new Filter(){
			@Override
			public boolean accept(T item) {
				return !sampleObject.equals(item);
			}});
	}
	
	
	public static  Iterator filter(final Iterator stream, final Filter filter) {
		final Iterator iter = new Iterator() {

			boolean finished;
			boolean slotOccupied;
			T       slot ;

			@Override
			public boolean hasNext() {
				if ( finished )
					return false ;
				while (!slotOccupied) {
					if ( !stream.hasNext() ) {
						finished = true ;
						break ;
					}
					T nextItem = stream.next() ;
					if ( filter.accept(nextItem) ) {
						slot = nextItem ;
						slotOccupied = true ;
						break ;
					}
				}
				return slotOccupied ;
			}

			@Override
			public T next() {
				if ( hasNext() ) {
					slotOccupied = false ;
					return slot ;
				}
				throw new NoSuchElementException("filter.next") ;
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException("filter.remove") ;
			}
		} ;

		return iter ;
	}


	public static  Iterator limit(final Iterator it, final int limit) {
		return new Iterator() {
			
			int pos;

			@Override
			public boolean hasNext() {
				return pos Iterator empty() {
		return new Iterator() {
			@Override
			public boolean hasNext() {
				return false;
			}

			@Override
			public T next() {
				throw new NoSuchElementException();
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}
	
	public static  Iterator single(final T element) {
		return new Iterator() {
			boolean used = false;
			
			@Override
			public boolean hasNext() {
				return !used;
			}

			@Override
			public T next() {
				if(!used) {
					used=true;
					return element;
				}
				throw new NoSuchElementException();
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}
	
	public static  Iterator side(final Iterator it, final SideEffect side) {
		return new Iterator() {

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

			@Override
			public T next() {
				T el = it.next();
				side.call(el);
				return el;
			}

			@Override
			public void remove() {
				
			}
		};
	}
	
	public static  void traverse(final Iterator it) {
		while(it.hasNext()) {
			it.next();
		}
	}
	
	public static  long count(final Iterator it) {
		long count=0;
		while(it.hasNext()){
			it.next();
			count++;
		}
		return count;
	}
}