com.googlecode.functionalcollections.FunctionalIterables Maven / Gradle / Ivy

Go to download
package com.googlecode.functionalcollections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;



public abstract class FunctionalIterables {

	public static  FunctionalIterable make(Iterable iterable) {
		return new StandardFunctionalIterable(iterable);
	}
	
	public static  FunctionalIterable make(F... elements) {
		return new StandardFunctionalIterable(Lists.newArrayList(elements));
	}
	
	public static  FunctionalIterable create() {
		return make(new ArrayList());
	}
	
	private static final class StandardFunctionalIterable implements FunctionalIterable {

		private final Iterable iterable;

		public StandardFunctionalIterable(Iterable iterable) {
			this.iterable = iterable;
		}

		public boolean all(Predicate predicate) {
			return Iterables.all(iterable, predicate);
		}

		public boolean any(Predicate predicate) {
			return Iterables.any(iterable, predicate);
		}

		public FunctionalIterable each(Block block) {
			Iterator iterator = iterable.iterator();
			
			while (iterator.hasNext()) {
				block.apply(iterator.next());
			}
			
			return this;
		}

		public FunctionalIterable filter(Predicate predicate) {
			return make(Iterables.filter(iterable, predicate));
		}
		
		public FunctionalIterable select(Predicate predicate) {
			return filter(predicate);
		}

		public F find(Predicate predicate) {
			return Iterables.find(iterable, predicate);
		}

		public F detect(Predicate predicate) {
			Iterator iterator = filter(predicate).iterator();
			return iterator.hasNext() ? iterator.next() : null;
		}
		
		public  FunctionalIterable transform(Function function) {
			return make(Iterables.transform(iterable, function));
		}
		
		public  FunctionalIterable map(Function function) {
			return transform(function);
		}

		public Iterator iterator() {
			return iterable.iterator();
		}

		public  M inject(M initial, Injector injector) {
			M memo = initial;
			for (F each : iterable) {
				memo = injector.apply(memo, each);
			}
			return memo;
		}

		public boolean contains(Object element) {
			return Iterables.contains(iterable, element);
		}

		public FunctionalIterable concat(Iterable target) {
			return make(Iterables.concat(iterable, target));
		}
		
		public FunctionalIterable concat(F... target) {
			return concat(Lists.newArrayList(target));
		}

		public FunctionalIterable cycle() {
			return make(Iterables.cycle(iterable));
		}

		public boolean elementsEqual(Iterable target) {
			return Iterables.elementsEqual(iterable, target);
		}

		public int frequency(Object element) {
			return Iterables.frequency(iterable, element);
		}

		public F get(int position) {
			return Iterables.get(iterable, position);
		}

		public F getLast() {
			return Iterables.getLast(iterable);
		}

		public F getOnlyElement() {
			return Iterables.getOnlyElement(iterable);
		}

		public F getOnlyElement(F defaultValue) {
			return Iterables.getOnlyElement(iterable, defaultValue);
		}

		public boolean isEmpty() {
			return Iterables.isEmpty(iterable);
		}

		public FunctionalIterable> paddedPartition(int size) {
			return make(Iterables.paddedPartition(iterable, size));
		}

		public FunctionalIterable> partition(int size) {
			return make(Iterables.partition(iterable, size));
		}

		public boolean removeAll(Collection elementsToRemove) {
			return Iterables.removeAll(iterable, elementsToRemove);
		}

		public boolean retainAll(Collection elementsToRetain) {
			return Iterables.retainAll(iterable, elementsToRetain);
		}

		public int size() {
			return Iterables.size(iterable);
		}

		public F[] toArray(Class type) {
			return Iterables.toArray(iterable, type);
		}

		public Collection toCollection() {
			if (Collection.class.isInstance(iterable)) {
				return (Collection) iterable;
			}
			return Lists.newArrayList(iterable);
		}

		public List toList() {
			if (List.class.isInstance(iterable)) {
				return (List) iterable;
			}
			return Lists.newArrayList(iterable);
		}

		public Set toSet() {
			if (Set.class.isInstance(iterable)) {
				return (Set) iterable;
			}
			return Sets.newLinkedHashSet(iterable);
		}
		
		public FunctionalIterable uniq() {
			return make(Sets.newLinkedHashSet(iterable));
		}

		public FunctionalIterable reverse() {
			return make(Iterables.reverse(Lists.newArrayList(iterable)));
		}

		public Iterator messagedIterator(final String messageOnLast) {
			final Iterator iterator = iterable.iterator();
			
			return new Iterator() {

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

				public F next() {
					if (!hasNext()) {
						throw new NoSuchElementException(messageOnLast);
					}
					return iterator.next();
				}

				public void remove() {
					iterator.remove();
				}
			};
		}

		@Override
		public String toString() {
			return Iterables.toString(iterable);
		}


//		public FunctionalIterable flatten() {
//			// TODO Auto-generated method stub
//			throw new UnsupportedOperationException("not yet implement.");
//		}

	
	}
	

	
	
}