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

Go to download
package com.googlecode.functionalcollections;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;

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



public abstract class FunctionalIterables {

	public static  FunctionalIterable make(Iterable iterable) {
		return new StandardFunctionalIterable(iterable);
	}
	
	
	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 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 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 contat(Iterable target) {
			return make(Iterables.concat(iterable, 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 FunctionalIterable flatten() {
//			// TODO Auto-generated method stub
//			throw new UnsupportedOperationException("not yet implement.");
//		}

	
	}
	

	
	
}