Enumerable.java

public abstract class Enumerable<T> {
    public static <T> Enumerable<T> from(final Enumerator<T> enumerator) {
        return new Enumerable<T>() {
            @Override
            public Enumerator<T> getEnumerator() {
                return enumerator;
            }
        };
    }

    public abstract Enumerator<T> getEnumerator();

    public void forEach(Action2<T, Integer> action) {
        Enumerator<T> enumerator = getEnumerator();
        int index = 0;
        while (enumerator.moveNext()) {
            action.invoke(enumerator.getCurrent(), index++);
        }
    }

    public void forEach(String expression, Func<JexlContext> contextGenerator) {
        Expression expr = JexlHelper.createExpression(expression);

        Enumerator<T> enumerator = getEnumerator();
        int index = 0;
        while (enumerator.moveNext()) {
            JexlContext context = null;
            if (contextGenerator != null) context = contextGenerator.invoke();
            if (context == null) context = new MapContext();
            context.set("item", enumerator.getCurrent());
            context.set("index", index++);
            expr.evaluate(context);
        }
    }

    public <TResult> Enumerable<TResult> select(final Func2<T, Integer, TResult> selector) {
        return from(new Enumerator<TResult>() {
            private Enumerator<T> source = getEnumerator();
            private TResult current;
            private int index = 0;

            @Override
            public boolean moveNext() {
                if (source.moveNext()) {
                    current = selector.invoke(source.getCurrent(), index++);
                    return true;
                } else {
                    return false;
                }
            }

            @Override
            public TResult getCurrent() {
                return current;
            }
        });
    }

    public Enumerable<Object> select(final String expression, final Func<JexlContext> contextGenerator) {
        return from(new Enumerator<Object>() {
            private Enumerator<T> source = getEnumerator();
            private Object current;
            private int index = 0;
            private Expression expr = JexlHelper.createExpression(expression);

            @Override
            public boolean moveNext() {
                if (source.moveNext()) {
                    JexlContext context = null;
                    if (contextGenerator != null) context = contextGenerator.invoke();
                    if (context == null) context = new MapContext();
                    context.set("item", source.getCurrent());
                    context.set("index", index++);
                    current = expr.evaluate(context);
                    return true;
                } else {
                    return false;
                }
            }

            @Override
            public Object getCurrent() {
                return current;
            }
        });
    }

    public Enumerable<T> where(final Func2<T, Integer, Boolean> predicate) {
        return from(new Enumerator<T>() {
            private Enumerator<T> source = getEnumerator();
            private T current;
            private int index = 0;

            @Override
            public boolean moveNext() {
                if (source.moveNext()) {
                    boolean result = predicate.invoke(source.getCurrent(), index++);
                    if (result) {
                        current = source.getCurrent();
                        return true;
                    } else {
                        return moveNext();
                    }
                } else {
                    return false;
                }
            }

            @Override
            public T getCurrent() {
                return current;
            }
        });
    }

    public Enumerable<T> where(final String expression, final Func<JexlContext> contextGenerator) {
        return from(new Enumerator<T>() {
            private Enumerator<T> source = getEnumerator();
            private T current;
            private int index = 0;
            private Expression expr = JexlHelper.createExpression(expression);

            @Override
            public boolean moveNext() {
                if (source.moveNext()) {
                    JexlContext context = null;
                    if (contextGenerator != null) context = contextGenerator.invoke();
                    if (context == null) context = new MapContext();
                    context.set("item", source.getCurrent());
                    context.set("index", index++);
                    boolean result = (Boolean)expr.evaluate(context);
                    if (result) {
                        current = source.getCurrent();
                        return true;
                    } else {
                        return moveNext();
                    }
                } else {
                    return false;
                }
            }

            @Override
            public T getCurrent() {
                return current;
            }
        });
    }
}

Enumerator.java

package net.azyobuzi.azyotter.saostar.linq;

public interface Enumerator<T> {
    boolean moveNext();
    T getCurrent();
}

JexlHelper.java

package net.azyobuzi.azyotter.saostar;

import org.apache.commons.jexl2.Expression;
import org.apache.commons.jexl2.JexlContext;
import org.apache.commons.jexl2.JexlEngine;

public class JexlHelper {
    private static final JexlEngine engine = new JexlEngine();

    public static Expression createExpression(String expression) {
        synchronized (engine) {
            return engine.createExpression(expression);
        }
    }

    public static Object evaluate(String expression, JexlContext context) {
        return createExpression(expression).evaluate(context);
    }
}